cmlib.h File Reference

#include <ntdef.h>
#include <ntifs.h>
#include <bugcodes.h>
#include <wine/unicode.h>
#include <wchar.h>
#include "hivedata.h"
#include "cmdata.h"

Include dependency graph for cmlib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_CM_USE_COUNT_LOG_ENTRY
struct	_CM_USE_COUNT_LOG
struct	_CMHIVE
struct	_HV_HIVE_CELL_PAIR
struct	_HV_TRACK_CELL_REF

Macros
#define	_CMLIB_DEBUG_   1
#define	CMLTRACE(x, ...)    if (x & CmlibTraceLevel) DbgPrint(__VA_ARGS__)
#define	_WINDEF_
#define	_WINBASE_
#define	_WINNLS_
#define	CMLIB_HCELL_DEBUG   0x01
#define	ROUND_UP(a, b)   ((((a)+(b)-1)/(b))*(b))
#define	ROUND_DOWN(a, b)   (((a)/(b))*(b))
#define	TAG_CM   ' MC'
#define	TAG_KCB   'bkMC'
#define	TAG_CMHIVE   'vHMC'
#define	TAG_CMSD   'DSMC'
#define	TAG_REGISTRY_STACK   'sRMC'
#define	CMAPI   NTAPI
#define	CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES   0x0
#define	CM_CHECK_REGISTRY_PURGE_VOLATILES   0x2
#define	CM_CHECK_REGISTRY_BOOTLOADER_PURGE_VOLATILES   0x4
#define	CM_CHECK_REGISTRY_VALIDATE_HIVE   0x8
#define	CM_CHECK_REGISTRY_FIX_HIVE   0x10
#define	CM_CHECK_REGISTRY_GOOD   0
#define	CM_CHECK_REGISTRY_INVALID_PARAMETER   1
#define	CM_CHECK_REGISTRY_SD_INVALID   2
#define	CM_CHECK_REGISTRY_HIVE_CORRUPT_SIGNATURE   3
#define	CM_CHECK_REGISTRY_BIN_SIZE_OR_OFFSET_CORRUPT   4
#define	CM_CHECK_REGISTRY_BIN_SIGNATURE_HEADER_CORRUPT   5
#define	CM_CHECK_REGISTRY_BAD_FREE_CELL   6
#define	CM_CHECK_REGISTRY_BAD_ALLOC_CELL   7
#define	CM_CHECK_REGISTRY_ALLOCATE_MEM_STACK_FAIL   8
#define	CM_CHECK_REGISTRY_ROOT_CELL_NOT_FOUND   9
#define	CM_CHECK_REGISTRY_BAD_LEXICOGRAPHICAL_ORDER   10
#define	CM_CHECK_REGISTRY_NODE_NOT_FOUND   11
#define	CM_CHECK_REGISTRY_SUBKEY_NOT_FOUND   12
#define	CM_CHECK_REGISTRY_TREE_TOO_MANY_LEVELS   13
#define	CM_CHECK_REGISTRY_KEY_CELL_NOT_ALLOCATED   14
#define	CM_CHECK_REGISTRY_CELL_DATA_NOT_FOUND   15
#define	CM_CHECK_REGISTRY_CELL_SIZE_NOT_SANE   16
#define	CM_CHECK_REGISTRY_KEY_NAME_LENGTH_ZERO   17
#define	CM_CHECK_REGISTRY_KEY_TOO_BIG_THAN_CELL   18
#define	CM_CHECK_REGISTRY_BAD_KEY_NODE_PARENT   19
#define	CM_CHECK_REGISTRY_BAD_KEY_NODE_SIGNATURE   20
#define	CM_CHECK_REGISTRY_KEY_CLASS_UNALLOCATED   21
#define	CM_CHECK_REGISTRY_VALUE_LIST_UNALLOCATED   22
#define	CM_CHECK_REGISTRY_VALUE_LIST_DATA_NOT_FOUND   23
#define	CM_CHECK_REGISTRY_VALUE_LIST_SIZE_NOT_SANE   24
#define	CM_CHECK_REGISTRY_VALUE_CELL_NIL   25
#define	CM_CHECK_REGISTRY_VALUE_CELL_UNALLOCATED   26
#define	CM_CHECK_REGISTRY_VALUE_CELL_DATA_NOT_FOUND   27
#define	CM_CHECK_REGISTRY_VALUE_CELL_SIZE_NOT_SANE   28
#define	CM_CHECK_REGISTRY_CORRUPT_VALUE_DATA   29
#define	CM_CHECK_REGISTRY_DATA_CELL_NOT_ALLOCATED   30
#define	CM_CHECK_REGISTRY_BAD_KEY_VALUE_SIGNATURE   31
#define	CM_CHECK_REGISTRY_STABLE_KEYS_ON_VOLATILE   32
#define	CM_CHECK_REGISTRY_SUBKEYS_LIST_UNALLOCATED   33
#define	CM_CHECK_REGISTRY_CORRUPT_SUBKEYS_INDEX   34
#define	CM_CHECK_REGISTRY_BAD_SUBKEY_COUNT   35
#define	CM_CHECK_REGISTRY_KEY_INDEX_CELL_UNALLOCATED   36
#define	CM_CHECK_REGISTRY_CORRUPT_LEAF_ON_ROOT   37
#define	CM_CHECK_REGISTRY_CORRUPT_LEAF_SIGNATURE   38
#define	CM_CHECK_REGISTRY_CORRUPT_KEY_INDEX_SIGNATURE   39
#define	CM_CHECK_REGISTRY_SUCCESS(StatusCode)   ((ULONG)(StatusCode) == CM_CHECK_REGISTRY_GOOD)
#define	CMP_SECURITY_HASH_LISTS   64
#define	STATIC_CELL_PAIR_COUNT   4
#define	ASSERT_VALUE_BIG(h, s)    ASSERTMSG("Big keys not supported!\n", !CmpIsKeyValueBig(h, s));
#define	HvGetCell(Hive, Cell)    (Hive)->GetCellRoutine(Hive, Cell)
#define	HvReleaseCell(Hive, Cell)

Typedefs
typedef ULONG	CM_CHECK_REGISTRY_STATUS
typedef struct _CM_KEY_SECURITY_CACHE_ENTRY *	PCM_KEY_SECURITY_CACHE_ENTRY
typedef struct _CM_KEY_CONTROL_BLOCK *	PCM_KEY_CONTROL_BLOCK
typedef struct _CM_CELL_REMAP_BLOCK *	PCM_CELL_REMAP_BLOCK
typedef struct _CM_USE_COUNT_LOG_ENTRY	CM_USE_COUNT_LOG_ENTRY
typedef struct _CM_USE_COUNT_LOG_ENTRY *	PCM_USE_COUNT_LOG_ENTRY
typedef struct _CM_USE_COUNT_LOG	CM_USE_COUNT_LOG
typedef struct _CM_USE_COUNT_LOG *	PCM_USE_COUNT_LOG
typedef struct _CMHIVE	CMHIVE
typedef struct _CMHIVE *	PCMHIVE
typedef struct _HV_HIVE_CELL_PAIR	HV_HIVE_CELL_PAIR
typedef struct _HV_HIVE_CELL_PAIR *	PHV_HIVE_CELL_PAIR
typedef struct _HV_TRACK_CELL_REF	HV_TRACK_CELL_REF
typedef struct _HV_TRACK_CELL_REF *	PHV_TRACK_CELL_REF

Functions
static BOOLEAN	CmpIsKeyValueSmall (OUT PULONG RealLength, IN ULONG Length)
static BOOLEAN	CmpIsKeyValueBig (IN PHHIVE Hive, IN ULONG Length)
NTSTATUS CMAPI	HvInitialize (PHHIVE RegistryHive, ULONG OperationType, ULONG HiveFlags, ULONG FileType, PVOID HiveData OPTIONAL, PALLOCATE_ROUTINE Allocate, PFREE_ROUTINE Free, PFILE_SET_SIZE_ROUTINE FileSetSize, PFILE_WRITE_ROUTINE FileWrite, PFILE_READ_ROUTINE FileRead, PFILE_FLUSH_ROUTINE FileFlush, ULONG Cluster OPTIONAL, PCUNICODE_STRING FileName OPTIONAL)
VOID CMAPI	HvFree (PHHIVE RegistryHive)
LONG CMAPI	HvGetCellSize (PHHIVE RegistryHive, PVOID Cell)
HCELL_INDEX CMAPI	HvAllocateCell (PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage, IN HCELL_INDEX Vicinity)
BOOLEAN CMAPI	HvIsCellAllocated (IN PHHIVE RegistryHive, IN HCELL_INDEX CellIndex)
HCELL_INDEX CMAPI	HvReallocateCell (PHHIVE RegistryHive, HCELL_INDEX CellOffset, ULONG Size)
VOID CMAPI	HvFreeCell (PHHIVE RegistryHive, HCELL_INDEX CellOffset)
BOOLEAN CMAPI	HvMarkCellDirty (PHHIVE RegistryHive, HCELL_INDEX CellOffset, BOOLEAN HoldingLock)
BOOLEAN CMAPI	HvIsCellDirty (IN PHHIVE Hive, IN HCELL_INDEX Cell)
BOOLEAN CMAPI	HvHiveWillShrink (IN PHHIVE RegistryHive)
BOOLEAN CMAPI	HvSyncHive (PHHIVE RegistryHive)
BOOLEAN CMAPI	HvWriteHive (PHHIVE RegistryHive)
BOOLEAN CMAPI	HvWriteAlternateHive (_In_ PHHIVE RegistryHive)
	Writes data to an alternate registry hive. An alternate hive is usually backed up by a primary hive. This function is tipically used to force write data into the alternate hive if both hives no longer match.
BOOLEAN CMAPI	HvSyncHiveFromRecover (_In_ PHHIVE RegistryHive)
	Synchronizes a hive with recovered data during a healing/resuscitation operation of the registry.
BOOLEAN CMAPI	HvTrackCellRef (IN OUT PHV_TRACK_CELL_REF CellRef, IN PHHIVE Hive, IN HCELL_INDEX Cell)
VOID CMAPI	HvReleaseFreeCellRefArray (IN OUT PHV_TRACK_CELL_REF CellRef)
PCELL_DATA CMAPI	HvpGetCellData (_In_ PHHIVE Hive, _In_ HCELL_INDEX CellIndex)
PHBIN CMAPI	HvpAddBin (PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage)
NTSTATUS CMAPI	HvpCreateHiveFreeCellList (PHHIVE Hive)
ULONG CMAPI	HvpHiveHeaderChecksum (PHBASE_BLOCK HiveHeader)
BOOLEAN CMAPI	HvpVerifyHiveHeader (_In_ PHBASE_BLOCK BaseBlock, _In_ ULONG FileType)
	Validates the base block header of a registry file (hive or log).
BOOLEAN CMAPI	CmIsSelfHealEnabled (_In_ BOOLEAN FixHive)
	Checks if self healing is permitted by the kernel and/or bootloader. Self healing is also triggered if such a request was prompted by the user to fix a broken hive. Such a request tipically comes from a registry repair tool such as the ReactOS Check Registry Utility.
BOOLEAN CMAPI	CmpRepairParentKey (_Inout_ PHHIVE Hive, _In_ HCELL_INDEX TargetKey, _In_ HCELL_INDEX ParentKey, _In_ BOOLEAN FixHive)
	Repairs the parent key from damage by removing the offending subkey cell.
BOOLEAN CMAPI	CmpRepairParentNode (_Inout_ PHHIVE Hive, _In_ HCELL_INDEX DirtyCell, _In_ HCELL_INDEX ParentCell, _Inout_ PCELL_DATA CellData, _In_ BOOLEAN FixHive)
	Repairs the parent of the node from damage due to parent cell and parent node incosistency.
BOOLEAN CMAPI	CmpRepairKeyNodeSignature (_Inout_ PHHIVE Hive, _In_ HCELL_INDEX DirtyCell, _Inout_ PCELL_DATA CellData, _In_ BOOLEAN FixHive)
	Repairs the key node signature from damage due to signature corruption.
BOOLEAN CMAPI	CmpRepairClassOfNodeKey (_Inout_ PHHIVE Hive, _In_ HCELL_INDEX DirtyCell, _Inout_ PCELL_DATA CellData, _In_ BOOLEAN FixHive)
	Repairs the class from damage due to class corruption within the node key.
BOOLEAN CMAPI	CmpRepairValueList (_Inout_ PHHIVE Hive, _In_ HCELL_INDEX CurrentCell, _In_ BOOLEAN FixHive)
	Repairs the value list due to corruption. The process involes by purging the whole damaged list.
BOOLEAN CMAPI	CmpRepairValueListCount (_Inout_ PHHIVE Hive, _In_ HCELL_INDEX CurrentCell, _In_ ULONG ListCountIndex, _Inout_ PCELL_DATA ValueListData, _In_ BOOLEAN FixHive)
	Repairs the value list count of key due to corruption. The process involves by removing one damaged value less from the list.
BOOLEAN CMAPI	CmpRepairSubKeyCounts (_Inout_ PHHIVE Hive, _In_ HCELL_INDEX CurrentCell, _In_ ULONG Count, _Inout_ PCELL_DATA CellData, _In_ BOOLEAN FixHive)
	Repairs the subkey list count due to corruption. The process involves by fixing the count itself with a sane count.
BOOLEAN CMAPI	CmpRepairSubKeyList (_Inout_ PHHIVE Hive, _In_ HCELL_INDEX CurrentCell, _Inout_ PCELL_DATA CellData, _In_ BOOLEAN FixHive)
	Repairs the subkey list due to corruption. The process involves by purging the whole damaged subkeys list.
BOOLEAN CMAPI	CmCreateRootNode (PHHIVE Hive, PCWSTR Name)
CM_CHECK_REGISTRY_STATUS NTAPI	HvValidateBin (_In_ PHHIVE Hive, _In_ PHBIN Bin)
	Validates a bin from a hive. It performs checks against the cells from this bin, ensuring the bin is not corrupt and that the cells are consistent with each other.
CM_CHECK_REGISTRY_STATUS NTAPI	HvValidateHive (_In_ PHHIVE Hive)
	Validates a registry hive. This function ensures that the storage of this hive has valid bins.
CM_CHECK_REGISTRY_STATUS NTAPI	CmCheckRegistry (_In_ PCMHIVE RegistryHive, _In_ ULONG Flags)
	Checks the registry that is consistent and its contents valid and not corrupted. More specifically this function performs a deep check of the registry for the following properties:
HCELL_INDEX NTAPI	CmpFindSubKeyByName (IN PHHIVE Hive, IN PCM_KEY_NODE Parent, IN PCUNICODE_STRING SearchName)
HCELL_INDEX NTAPI	CmpFindSubKeyByNumber (IN PHHIVE Hive, IN PCM_KEY_NODE Node, IN ULONG Number)
ULONG NTAPI	CmpComputeHashKey (IN ULONG Hash, IN PCUNICODE_STRING Name, IN BOOLEAN AllowSeparators)
BOOLEAN NTAPI	CmpAddSubKey (IN PHHIVE Hive, IN HCELL_INDEX Parent, IN HCELL_INDEX Child)
BOOLEAN NTAPI	CmpRemoveSubKey (IN PHHIVE Hive, IN HCELL_INDEX ParentKey, IN HCELL_INDEX TargetKey)
BOOLEAN NTAPI	CmpMarkIndexDirty (IN PHHIVE Hive, HCELL_INDEX ParentKey, HCELL_INDEX TargetKey)
LONG NTAPI	CmpCompareCompressedName (IN PCUNICODE_STRING SearchName, IN PWCHAR CompressedName, IN ULONG NameLength)
USHORT NTAPI	CmpNameSize (IN PHHIVE Hive, IN PCUNICODE_STRING Name)
USHORT NTAPI	CmpCompressedNameSize (IN PWCHAR Name, IN ULONG Length)
USHORT NTAPI	CmpCopyName (IN PHHIVE Hive, OUT PWCHAR Destination, IN PCUNICODE_STRING Source)
VOID NTAPI	CmpCopyCompressedName (OUT PWCHAR Destination, IN ULONG DestinationLength, IN PWCHAR Source, IN ULONG SourceLength)
BOOLEAN NTAPI	CmpFindNameInList (IN PHHIVE Hive, IN PCHILD_LIST ChildList, IN PCUNICODE_STRING Name, OUT PULONG ChildIndex OPTIONAL, OUT PHCELL_INDEX CellIndex)
HCELL_INDEX NTAPI	CmpFindValueByName (IN PHHIVE Hive, IN PCM_KEY_NODE KeyNode, IN PCUNICODE_STRING Name)
PCELL_DATA NTAPI	CmpValueToData (IN PHHIVE Hive, IN PCM_KEY_VALUE Value, OUT PULONG Length)
NTSTATUS NTAPI	CmpSetValueDataNew (IN PHHIVE Hive, IN PVOID Data, IN ULONG DataSize, IN HSTORAGE_TYPE StorageType, IN HCELL_INDEX ValueCell, OUT PHCELL_INDEX DataCell)
NTSTATUS NTAPI	CmpAddValueToList (IN PHHIVE Hive, IN HCELL_INDEX ValueCell, IN ULONG Index, IN HSTORAGE_TYPE StorageType, IN OUT PCHILD_LIST ChildList)
BOOLEAN NTAPI	CmpFreeValue (IN PHHIVE Hive, IN HCELL_INDEX Cell)
BOOLEAN NTAPI	CmpMarkValueDataDirty (IN PHHIVE Hive, IN PCM_KEY_VALUE Value)
BOOLEAN NTAPI	CmpFreeValueData (IN PHHIVE Hive, IN HCELL_INDEX DataCell, IN ULONG DataLength)
NTSTATUS NTAPI	CmpRemoveValueFromList (IN PHHIVE Hive, IN ULONG Index, IN OUT PCHILD_LIST ChildList)
BOOLEAN NTAPI	CmpGetValueData (IN PHHIVE Hive, IN PCM_KEY_VALUE Value, OUT PULONG Length, OUT PVOID *Buffer, OUT PBOOLEAN BufferAllocated, OUT PHCELL_INDEX CellToRelease)
NTSTATUS NTAPI	CmpCopyKeyValueList (IN PHHIVE SourceHive, IN PCHILD_LIST SrcValueList, IN PHHIVE DestinationHive, IN OUT PCHILD_LIST DestValueList, IN HSTORAGE_TYPE StorageType)
NTSTATUS NTAPI	CmpFreeKeyByCell (IN PHHIVE Hive, IN HCELL_INDEX Cell, IN BOOLEAN Unlink)
VOID NTAPI	CmpRemoveSecurityCellList (IN PHHIVE Hive, IN HCELL_INDEX SecurityCell)
VOID NTAPI	CmpFreeSecurityDescriptor (IN PHHIVE Hive, IN HCELL_INDEX Cell)
PVOID NTAPI	CmpAllocate (IN SIZE_T Size, IN BOOLEAN Paged, IN ULONG Tag)
VOID NTAPI	CmpFree (IN PVOID Ptr, IN ULONG Quota)

Variables
ULONG	CmlibTraceLevel

Macro Definition Documentation

_CMLIB_DEBUG_

#define _CMLIB_DEBUG_   1

Definition at line 15 of file cmlib.h.

_WINBASE_

#define _WINBASE_

Definition at line 185 of file cmlib.h.

_WINDEF_

#define _WINDEF_

Definition at line 184 of file cmlib.h.

_WINNLS_

#define _WINNLS_

Definition at line 186 of file cmlib.h.

ASSERT_VALUE_BIG

#define ASSERT_VALUE_BIG	(		h,
			s
	)		ASSERTMSG("Big keys not supported!\n", !CmpIsKeyValueBig(h, s));

Definition at line 386 of file cmlib.h.

CM_CHECK_REGISTRY_ALLOCATE_MEM_STACK_FAIL

#define CM_CHECK_REGISTRY_ALLOCATE_MEM_STACK_FAIL   8

Definition at line 245 of file cmlib.h.

CM_CHECK_REGISTRY_BAD_ALLOC_CELL

#define CM_CHECK_REGISTRY_BAD_ALLOC_CELL   7

Definition at line 244 of file cmlib.h.

CM_CHECK_REGISTRY_BAD_FREE_CELL

#define CM_CHECK_REGISTRY_BAD_FREE_CELL   6

Definition at line 243 of file cmlib.h.

CM_CHECK_REGISTRY_BAD_KEY_NODE_PARENT

#define CM_CHECK_REGISTRY_BAD_KEY_NODE_PARENT   19

Definition at line 256 of file cmlib.h.

CM_CHECK_REGISTRY_BAD_KEY_NODE_SIGNATURE

#define CM_CHECK_REGISTRY_BAD_KEY_NODE_SIGNATURE   20

Definition at line 257 of file cmlib.h.

CM_CHECK_REGISTRY_BAD_KEY_VALUE_SIGNATURE

#define CM_CHECK_REGISTRY_BAD_KEY_VALUE_SIGNATURE   31

Definition at line 268 of file cmlib.h.

CM_CHECK_REGISTRY_BAD_LEXICOGRAPHICAL_ORDER

#define CM_CHECK_REGISTRY_BAD_LEXICOGRAPHICAL_ORDER   10

Definition at line 247 of file cmlib.h.

CM_CHECK_REGISTRY_BAD_SUBKEY_COUNT

#define CM_CHECK_REGISTRY_BAD_SUBKEY_COUNT   35

Definition at line 272 of file cmlib.h.

CM_CHECK_REGISTRY_BIN_SIGNATURE_HEADER_CORRUPT

#define CM_CHECK_REGISTRY_BIN_SIGNATURE_HEADER_CORRUPT   5

Definition at line 242 of file cmlib.h.

CM_CHECK_REGISTRY_BIN_SIZE_OR_OFFSET_CORRUPT

#define CM_CHECK_REGISTRY_BIN_SIZE_OR_OFFSET_CORRUPT   4

Definition at line 241 of file cmlib.h.

CM_CHECK_REGISTRY_BOOTLOADER_PURGE_VOLATILES

#define CM_CHECK_REGISTRY_BOOTLOADER_PURGE_VOLATILES   0x4

Definition at line 230 of file cmlib.h.

CM_CHECK_REGISTRY_CELL_DATA_NOT_FOUND

#define CM_CHECK_REGISTRY_CELL_DATA_NOT_FOUND   15

Definition at line 252 of file cmlib.h.

CM_CHECK_REGISTRY_CELL_SIZE_NOT_SANE

#define CM_CHECK_REGISTRY_CELL_SIZE_NOT_SANE   16

Definition at line 253 of file cmlib.h.

CM_CHECK_REGISTRY_CORRUPT_KEY_INDEX_SIGNATURE

#define CM_CHECK_REGISTRY_CORRUPT_KEY_INDEX_SIGNATURE   39

Definition at line 276 of file cmlib.h.

CM_CHECK_REGISTRY_CORRUPT_LEAF_ON_ROOT

#define CM_CHECK_REGISTRY_CORRUPT_LEAF_ON_ROOT   37

Definition at line 274 of file cmlib.h.

CM_CHECK_REGISTRY_CORRUPT_LEAF_SIGNATURE

#define CM_CHECK_REGISTRY_CORRUPT_LEAF_SIGNATURE   38

Definition at line 275 of file cmlib.h.

CM_CHECK_REGISTRY_CORRUPT_SUBKEYS_INDEX

#define CM_CHECK_REGISTRY_CORRUPT_SUBKEYS_INDEX   34

Definition at line 271 of file cmlib.h.

CM_CHECK_REGISTRY_CORRUPT_VALUE_DATA

#define CM_CHECK_REGISTRY_CORRUPT_VALUE_DATA   29

Definition at line 266 of file cmlib.h.

CM_CHECK_REGISTRY_DATA_CELL_NOT_ALLOCATED

#define CM_CHECK_REGISTRY_DATA_CELL_NOT_ALLOCATED   30

Definition at line 267 of file cmlib.h.

CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES

#define CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES   0x0

Definition at line 228 of file cmlib.h.

CM_CHECK_REGISTRY_FIX_HIVE

#define CM_CHECK_REGISTRY_FIX_HIVE   0x10

Definition at line 232 of file cmlib.h.

CM_CHECK_REGISTRY_GOOD

#define CM_CHECK_REGISTRY_GOOD   0

Definition at line 237 of file cmlib.h.

CM_CHECK_REGISTRY_HIVE_CORRUPT_SIGNATURE

#define CM_CHECK_REGISTRY_HIVE_CORRUPT_SIGNATURE   3

Definition at line 240 of file cmlib.h.

CM_CHECK_REGISTRY_INVALID_PARAMETER

#define CM_CHECK_REGISTRY_INVALID_PARAMETER   1

Definition at line 238 of file cmlib.h.

CM_CHECK_REGISTRY_KEY_CELL_NOT_ALLOCATED

#define CM_CHECK_REGISTRY_KEY_CELL_NOT_ALLOCATED   14

Definition at line 251 of file cmlib.h.

CM_CHECK_REGISTRY_KEY_CLASS_UNALLOCATED

#define CM_CHECK_REGISTRY_KEY_CLASS_UNALLOCATED   21

Definition at line 258 of file cmlib.h.

CM_CHECK_REGISTRY_KEY_INDEX_CELL_UNALLOCATED

#define CM_CHECK_REGISTRY_KEY_INDEX_CELL_UNALLOCATED   36

Definition at line 273 of file cmlib.h.

CM_CHECK_REGISTRY_KEY_NAME_LENGTH_ZERO

#define CM_CHECK_REGISTRY_KEY_NAME_LENGTH_ZERO   17

Definition at line 254 of file cmlib.h.

CM_CHECK_REGISTRY_KEY_TOO_BIG_THAN_CELL

#define CM_CHECK_REGISTRY_KEY_TOO_BIG_THAN_CELL   18

Definition at line 255 of file cmlib.h.

CM_CHECK_REGISTRY_NODE_NOT_FOUND

#define CM_CHECK_REGISTRY_NODE_NOT_FOUND   11

Definition at line 248 of file cmlib.h.

CM_CHECK_REGISTRY_PURGE_VOLATILES

#define CM_CHECK_REGISTRY_PURGE_VOLATILES   0x2

Definition at line 229 of file cmlib.h.

CM_CHECK_REGISTRY_ROOT_CELL_NOT_FOUND

#define CM_CHECK_REGISTRY_ROOT_CELL_NOT_FOUND   9

Definition at line 246 of file cmlib.h.

CM_CHECK_REGISTRY_SD_INVALID

#define CM_CHECK_REGISTRY_SD_INVALID   2

Definition at line 239 of file cmlib.h.

CM_CHECK_REGISTRY_STABLE_KEYS_ON_VOLATILE

#define CM_CHECK_REGISTRY_STABLE_KEYS_ON_VOLATILE   32

Definition at line 269 of file cmlib.h.

CM_CHECK_REGISTRY_SUBKEY_NOT_FOUND

#define CM_CHECK_REGISTRY_SUBKEY_NOT_FOUND   12

Definition at line 249 of file cmlib.h.

CM_CHECK_REGISTRY_SUBKEYS_LIST_UNALLOCATED

#define CM_CHECK_REGISTRY_SUBKEYS_LIST_UNALLOCATED   33

Definition at line 270 of file cmlib.h.

CM_CHECK_REGISTRY_SUCCESS

#define CM_CHECK_REGISTRY_SUCCESS

(

StatusCode

)

((ULONG)(StatusCode) == CM_CHECK_REGISTRY_GOOD)

Definition at line 281 of file cmlib.h.

CM_CHECK_REGISTRY_TREE_TOO_MANY_LEVELS

#define CM_CHECK_REGISTRY_TREE_TOO_MANY_LEVELS   13

Definition at line 250 of file cmlib.h.

CM_CHECK_REGISTRY_VALIDATE_HIVE

#define CM_CHECK_REGISTRY_VALIDATE_HIVE   0x8

Definition at line 231 of file cmlib.h.

CM_CHECK_REGISTRY_VALUE_CELL_DATA_NOT_FOUND

#define CM_CHECK_REGISTRY_VALUE_CELL_DATA_NOT_FOUND   27

Definition at line 264 of file cmlib.h.

CM_CHECK_REGISTRY_VALUE_CELL_NIL

#define CM_CHECK_REGISTRY_VALUE_CELL_NIL   25

Definition at line 262 of file cmlib.h.

CM_CHECK_REGISTRY_VALUE_CELL_SIZE_NOT_SANE

#define CM_CHECK_REGISTRY_VALUE_CELL_SIZE_NOT_SANE   28

Definition at line 265 of file cmlib.h.

CM_CHECK_REGISTRY_VALUE_CELL_UNALLOCATED

#define CM_CHECK_REGISTRY_VALUE_CELL_UNALLOCATED   26

Definition at line 263 of file cmlib.h.

CM_CHECK_REGISTRY_VALUE_LIST_DATA_NOT_FOUND

#define CM_CHECK_REGISTRY_VALUE_LIST_DATA_NOT_FOUND   23

Definition at line 260 of file cmlib.h.

CM_CHECK_REGISTRY_VALUE_LIST_SIZE_NOT_SANE

#define CM_CHECK_REGISTRY_VALUE_LIST_SIZE_NOT_SANE   24

Definition at line 261 of file cmlib.h.

CM_CHECK_REGISTRY_VALUE_LIST_UNALLOCATED

#define CM_CHECK_REGISTRY_VALUE_LIST_UNALLOCATED   22

Definition at line 259 of file cmlib.h.

CMAPI

#define CMAPI   NTAPI

Definition at line 218 of file cmlib.h.

CMLIB_HCELL_DEBUG

#define CMLIB_HCELL_DEBUG   0x01

Definition at line 193 of file cmlib.h.

CMLTRACE

#define CMLTRACE	(		x,
			...
	)		if (x & CmlibTraceLevel) DbgPrint(__VA_ARGS__)

Definition at line 172 of file cmlib.h.

CMP_SECURITY_HASH_LISTS

#define CMP_SECURITY_HASH_LISTS   64

Definition at line 294 of file cmlib.h.

HvGetCell

#define HvGetCell	(		Hive,
			Cell
	)		(Hive)->GetCellRoutine(Hive, Cell)

Definition at line 457 of file cmlib.h.

HvReleaseCell

#define HvReleaseCell	(		Hive,
			Cell
	)

Value:

do {                                            \
    if ((Hive)->ReleaseCellRoutine)             \
        (Hive)->ReleaseCellRoutine(Hive, Cell); \
} while(0)

Definition at line 460 of file cmlib.h.

ROUND_DOWN

#define ROUND_DOWN	(		a,
			b
	)		(((a)/(b))*(b))

Definition at line 197 of file cmlib.h.

ROUND_UP

#define ROUND_UP	(		a,
			b
	)		((((a)+(b)-1)/(b))*(b))

Definition at line 196 of file cmlib.h.

STATIC_CELL_PAIR_COUNT

#define STATIC_CELL_PAIR_COUNT   4

Definition at line 367 of file cmlib.h.

TAG_CM

#define TAG_CM   ' MC'

Definition at line 212 of file cmlib.h.

TAG_CMHIVE

#define TAG_CMHIVE   'vHMC'

Definition at line 214 of file cmlib.h.

TAG_CMSD

#define TAG_CMSD   'DSMC'

Definition at line 215 of file cmlib.h.

TAG_KCB

#define TAG_KCB   'bkMC'

Definition at line 213 of file cmlib.h.

TAG_REGISTRY_STACK

#define TAG_REGISTRY_STACK   'sRMC'

Definition at line 216 of file cmlib.h.

Typedef Documentation

CM_CHECK_REGISTRY_STATUS

typedef ULONG CM_CHECK_REGISTRY_STATUS

Definition at line 223 of file cmlib.h.

CM_USE_COUNT_LOG

typedef struct _CM_USE_COUNT_LOG CM_USE_COUNT_LOG

CM_USE_COUNT_LOG_ENTRY

typedef struct _CM_USE_COUNT_LOG_ENTRY CM_USE_COUNT_LOG_ENTRY

CMHIVE

typedef struct _CMHIVE CMHIVE

HV_HIVE_CELL_PAIR

typedef struct _HV_HIVE_CELL_PAIR HV_HIVE_CELL_PAIR

HV_TRACK_CELL_REF

typedef struct _HV_TRACK_CELL_REF HV_TRACK_CELL_REF

PCM_CELL_REMAP_BLOCK

typedef struct _CM_CELL_REMAP_BLOCK* PCM_CELL_REMAP_BLOCK

Definition at line 291 of file cmlib.h.

PCM_KEY_CONTROL_BLOCK

typedef struct _CM_KEY_CONTROL_BLOCK* PCM_KEY_CONTROL_BLOCK

Definition at line 290 of file cmlib.h.

PCM_KEY_SECURITY_CACHE_ENTRY

typedef struct _CM_KEY_SECURITY_CACHE_ENTRY* PCM_KEY_SECURITY_CACHE_ENTRY

Definition at line 289 of file cmlib.h.

PCM_USE_COUNT_LOG

typedef struct _CM_USE_COUNT_LOG * PCM_USE_COUNT_LOG

PCM_USE_COUNT_LOG_ENTRY

typedef struct _CM_USE_COUNT_LOG_ENTRY * PCM_USE_COUNT_LOG_ENTRY

PCMHIVE

typedef struct _CMHIVE * PCMHIVE

PHV_HIVE_CELL_PAIR

typedef struct _HV_HIVE_CELL_PAIR * PHV_HIVE_CELL_PAIR

PHV_TRACK_CELL_REF

typedef struct _HV_TRACK_CELL_REF * PHV_TRACK_CELL_REF

Function Documentation

CmCheckRegistry()

CM_CHECK_REGISTRY_STATUS NTAPI CmCheckRegistry	(	_In_ PCMHIVE	RegistryHive,
		_In_ ULONG	Flags
	)

Checks the registry that is consistent and its contents valid and not corrupted. More specifically this function performs a deep check of the registry for the following properties:

• That the security cache cell of the registry is OK
• That bins and cells are consistent with each other
• That the child subkey cell points to the parent
• That the key itself has sane sizes
• That the class, values and subkeys lists are valid
• Much more

Parameters

[in]	Hive	A pointer to a CM hive of the registry to be checked in question.
[in]	Flags	A bit mask flag used to influence the process of volatile keys purging. See Remarks for further information.

Returns

This function returns a CM (Configuration Manager) check registry status code. A code of CM_CHECK_REGISTRY_GOOD of value 0 indicates the registry hive is valid and not corrupted. A non zero unsigned integer value indicates a failure. Consult other private routines in this file for other failure status codes.

Remarks

During a load operation CmCheckRegistry can purge the volatile data of registry (or not) depending on the submitted flag bit mask by the caller. The following supported flags are:

CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES – Tells the function that volatile data purging must not be done.

CM_CHECK_REGISTRY_PURGE_VOLATILES - Tells the function to purge out volatile information data from a registry hive, on demand. Purging doesn't come into action if no volatile data has been found.

CM_CHECK_REGISTRY_BOOTLOADER_PURGE_VOLATILES - A special flag used by FreeLdr and Environ. When this flag is set the function will not clean up the volatile storage but it will unintialize the storage instead (this is the case if the given registry hive for validation is a XP Beta 1 hive or newer). Otherwise it will perform a normal cleanup of the volatile storage.

CM_CHECK_REGISTRY_VALIDATE_HIVE - Tells the function to perform a thorough analysation of the underlying hive's bins and cells before doing validation of the registry tree. HvValidateHive function is called in this case.

CM_CHECK_REGISTRY_FIX_HIVE - Tells the function to fix the target registry hive if it is damaged. Usually this flag comes from a registry repair tool where the user asked to for its damaged hive to be fixed. In this case a self-heal procedure against the hive is performed.

Definition at line 1633 of file cmcheck.c.

{
    CM_CHECK_REGISTRY_STATUS CmStatusCode;
    PHHIVE Hive;
    BOOLEAN ShouldFixHive = FALSE;
 
    PAGED_CODE();
 
    /* Bail out if the caller did not give a hive */
    if (!RegistryHive)
    {
        DPRINT1("No registry hive given for check\n");
        return CM_CHECK_REGISTRY_INVALID_PARAMETER;
    }
 
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
    /*
     * The master hive is the root of the registry,
     * it holds all other hives together. So do not
     * do any validation checks.
     */
    if (RegistryHive == CmiVolatileHive)
    {
        DPRINT("This is master registry hive, don't do anything\n");
        return CM_CHECK_REGISTRY_GOOD;
    }
#endif
 
    /* Bail out if no valid flag is given */
    if (Flags & ~(CM_CHECK_REGISTRY_DONT_PURGE_VOLATILES       |
                  CM_CHECK_REGISTRY_PURGE_VOLATILES            |
                  CM_CHECK_REGISTRY_BOOTLOADER_PURGE_VOLATILES |
                  CM_CHECK_REGISTRY_VALIDATE_HIVE              |
                  CM_CHECK_REGISTRY_FIX_HIVE))
    {
        DPRINT1("Invalid flag for registry check given (flag %lu)\n", Flags);
        return CM_CHECK_REGISTRY_INVALID_PARAMETER;
    }
 
    /*
     * Obtain the hive and check if the caller wants
     * that the hive to be validated.
     */
    Hive = GET_HHIVE(RegistryHive);
    if (Flags & CM_CHECK_REGISTRY_VALIDATE_HIVE)
    {
        CmStatusCode = HvValidateHive(Hive);
        if (!CM_CHECK_REGISTRY_SUCCESS(CmStatusCode))
        {
            DPRINT1("The hive is not valid (hive 0x%p, check status code %lu)\n", Hive, CmStatusCode);
            return CmStatusCode;
        }
    }
 
    /*
     * A registry repair tool such as the ReactOS Check Registry
     * Utility wants the damaged hive to be fixed as we check the
     * target hive.
     */
    if (Flags & CM_CHECK_REGISTRY_FIX_HIVE)
    {
        ShouldFixHive = TRUE;
    }
 
    /*
     * FIXME: Currently ReactOS does not implement security
     * caching algorithms so it's pretty pointless to implement
     * security descriptors validation checks at this moment.
     * When the time comes to implement these, we would need
     * to implement security checks here as well.
     */
 
    /* Call the internal API to do the rest of the work bulk */
    CmStatusCode = CmpValidateRegistryInternal(Hive, Flags, FALSE, ShouldFixHive);
    if (!CM_CHECK_REGISTRY_SUCCESS(CmStatusCode))
    {
        DPRINT1("The hive is not valid (hive 0x%p, check status code %lu)\n", Hive, CmStatusCode);
        return CmStatusCode;
    }
 
    return CmStatusCode;
}

Referenced by BiInitializeAndValidateHive(), CmFlushKey(), CmpInitializeHive(), CmSaveKey(), CmSaveMergedKeys(), and RegInitializeHive().

CmCreateRootNode()

BOOLEAN CMAPI CmCreateRootNode	(	PHHIVE	Hive,
		PCWSTR	Name
	)

Definition at line 17 of file cminit.c.

{
    UNICODE_STRING KeyName;
    PCM_KEY_NODE KeyCell;
    HCELL_INDEX RootCellIndex;
 
    /* Initialize the node name and allocate it */
    RtlInitUnicodeString(&KeyName, Name);
    RootCellIndex = HvAllocateCell(Hive,
                                   FIELD_OFFSET(CM_KEY_NODE, Name) +
                                   CmpNameSize(Hive, &KeyName),
                                   Stable,
                                   HCELL_NIL);
    if (RootCellIndex == HCELL_NIL) return FALSE;
 
    /* Seutp the base block */
    Hive->BaseBlock->RootCell = RootCellIndex;
    Hive->BaseBlock->CheckSum = HvpHiveHeaderChecksum(Hive->BaseBlock);
 
    /* Get the key cell */
    KeyCell = (PCM_KEY_NODE)HvGetCell(Hive, RootCellIndex);
    if (!KeyCell)
    {
        HvFreeCell(Hive, RootCellIndex);
        return FALSE;
    }
 
    /* Setup the cell */
    KeyCell->Signature = CM_KEY_NODE_SIGNATURE;
    KeyCell->Flags = KEY_HIVE_ENTRY | KEY_NO_DELETE;
    // KeQuerySystemTime(&KeyCell->LastWriteTime);
    KeyCell->LastWriteTime.QuadPart = 0ULL;
    KeyCell->Parent = HCELL_NIL;
    KeyCell->SubKeyCounts[Stable] = 0;
    KeyCell->SubKeyCounts[Volatile] = 0;
    KeyCell->SubKeyLists[Stable] = HCELL_NIL;
    KeyCell->SubKeyLists[Volatile] = HCELL_NIL;
    KeyCell->ValueList.Count = 0;
    KeyCell->ValueList.List = HCELL_NIL;
    KeyCell->Security = HCELL_NIL;
    KeyCell->Class = HCELL_NIL;
    KeyCell->ClassLength = 0;
    KeyCell->MaxNameLen = 0;
    KeyCell->MaxClassLen = 0;
    KeyCell->MaxValueNameLen = 0;
    KeyCell->MaxValueDataLen = 0;
    KeyCell->NameLength = CmpCopyName(Hive, KeyCell->Name, &KeyName);
    if (KeyCell->NameLength < KeyName.Length) KeyCell->Flags |= KEY_COMP_NAME;
 
    /* Return success */
    HvReleaseCell(Hive, RootCellIndex);
    return TRUE;
}

Referenced by CmiInitializeHive().

CmIsSelfHealEnabled()

BOOLEAN CMAPI CmIsSelfHealEnabled

(

_In_ BOOLEAN

FixHive

)

Checks if self healing is permitted by the kernel and/or bootloader. Self healing is also triggered if such a request was prompted by the user to fix a broken hive. Such a request tipically comes from a registry repair tool such as the ReactOS Check Registry Utility.

Parameters

[in]

FixHive

If set to TRUE, self heal is triggered and the target hive will be fixed. Otherwise the hive will not be fixed.

Returns

Returns TRUE if self healing is possible, FALSE otherwise.

Definition at line 369 of file cmheal.c.

{
    PAGED_CODE();
 
    if (FixHive)
        return TRUE;
 
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
    if (CmpSelfHeal || (CmpBootType & HBOOT_TYPE_SELF_HEAL))
        return TRUE;
#endif
 
    return FALSE;
}

Referenced by CmpRepairClassOfNodeKey(), CmpRepairKeyNodeSignature(), CmpRepairParentKey(), CmpRepairParentNode(), CmpRepairSubKeyCounts(), CmpRepairSubKeyList(), CmpRepairValueList(), CmpRepairValueListCount(), HvpInitializeMemoryHive(), HvpRecoverDataFromLog(), and HvpRecoverHeaderFromLog().

CmpAddSubKey()

BOOLEAN NTAPI CmpAddSubKey	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	Parent,
		IN HCELL_INDEX	Child
	)

Definition at line 1465 of file cmindex.c.

{
    PCM_KEY_NODE KeyNode;
    PCM_KEY_INDEX Index;
    PCM_KEY_FAST_INDEX OldIndex;
    UNICODE_STRING Name;
    HCELL_INDEX IndexCell = HCELL_NIL, CellToRelease = HCELL_NIL, LeafCell;
    PHCELL_INDEX RootPointer = NULL;
    ULONG Type, i;
    BOOLEAN IsCompressed;
    PAGED_CODE();
 
    /* Get the key node */
    KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Child);
    if (!KeyNode)
    {
        /* Shouldn't happen */
        ASSERT(FALSE);
        return FALSE;
    }
 
    /* Check if the name is compressed */
    if (KeyNode->Flags & KEY_COMP_NAME)
    {
        /* Remember for later */
        IsCompressed = TRUE;
 
        /* Create the compressed name and allocate it */
        Name.Length = CmpCompressedNameSize(KeyNode->Name, KeyNode->NameLength);
        Name.MaximumLength = Name.Length;
        Name.Buffer = Hive->Allocate(Name.Length, TRUE, TAG_CM);
        if (!Name.Buffer)
        {
            /* Release the cell and fail */
            HvReleaseCell(Hive, Child);
            ASSERT(FALSE);
            return FALSE;
        }
 
        /* Copy the compressed name */
        CmpCopyCompressedName(Name.Buffer,
                              Name.MaximumLength,
                              KeyNode->Name,
                              KeyNode->NameLength);
    }
    else
    {
        /* Remember for later */
        IsCompressed = FALSE;
 
        /* Build the unicode string */
        Name.Length = KeyNode->NameLength;
        Name.MaximumLength = KeyNode->NameLength;
        Name.Buffer = &KeyNode->Name[0];
    }
 
    /* Release the cell */
    HvReleaseCell(Hive, Child);
 
    /* Get the parent node */
    KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Parent);
    if (!KeyNode)
    {
        /* Not handled */
        ASSERT(FALSE);
    }
 
    /* Find out the type of the cell, and check if this is the first subkey */
    Type = HvGetCellType(Child);
    if (!KeyNode->SubKeyCounts[Type])
    {
        /* Allocate a fast leaf */
        IndexCell = HvAllocateCell(Hive, sizeof(CM_KEY_FAST_INDEX), Type, HCELL_NIL);
        if (IndexCell == HCELL_NIL)
        {
            /* Not handled */
            ASSERT(FALSE);
        }
 
        /* Get the leaf cell */
        Index = (PCM_KEY_INDEX)HvGetCell(Hive, IndexCell);
        if (!Index)
        {
            /* Shouldn't happen */
            ASSERT(FALSE);
        }
 
        /* Now check what kind of hive we're dealing with */
        if (Hive->Version >= 5)
        {
            /* XP Hive: Use hash leaf */
            Index->Signature = CM_KEY_HASH_LEAF;
        }
        else if (Hive->Version >= 3)
        {
            /* Windows 2000 and ReactOS: Use fast leaf */
            Index->Signature = CM_KEY_FAST_LEAF;
        }
        else
        {
            /* NT 4: Use index leaf */
            Index->Signature = CM_KEY_INDEX_LEAF;
        }
 
        /* Setup the index list */
        Index->Count = 0;
        KeyNode->SubKeyLists[Type] = IndexCell;
    }
    else
    {
        /* We already have an index, get it */
        Index = (PCM_KEY_INDEX)HvGetCell(Hive, KeyNode->SubKeyLists[Type]);
        if (!Index)
        {
            /* Not handled */
            ASSERT(FALSE);
        }
 
        /* Remember to release the cell later */
        CellToRelease = KeyNode->SubKeyLists[Type];
 
        /* Check if this is a fast leaf that's gotten too full */
        if ((Index->Signature == CM_KEY_FAST_LEAF) &&
            (Index->Count >= CmpMaxFastIndexPerHblock))
        {
            DPRINT("Doing Fast->Slow Leaf conversion\n");
 
            /* Mark this cell as dirty */
            HvMarkCellDirty(Hive, CellToRelease, FALSE);
 
            /* Convert */
            OldIndex = (PCM_KEY_FAST_INDEX)Index;
 
            for (i = 0; i < OldIndex->Count; i++)
            {
                Index->List[i] = OldIndex->List[i].Cell;
            }
 
            /* Set the new type value */
            Index->Signature = CM_KEY_INDEX_LEAF;
        }
        else if (((Index->Signature == CM_KEY_INDEX_LEAF) ||
                  (Index->Signature == CM_KEY_HASH_LEAF)) &&
                  (Index->Count >= CmpMaxIndexPerHblock))
        {
            /* This is an old/hashed leaf that's gotten too large, root it */
            IndexCell = HvAllocateCell(Hive,
                                      sizeof(CM_KEY_INDEX) +
                                      sizeof(HCELL_INDEX),
                                      Type,
                                      HCELL_NIL);
            if (IndexCell == HCELL_NIL)
            {
                /* Not handled */
                ASSERT(FALSE);
            }
 
            /* Get the index cell */
            Index = (PCM_KEY_INDEX)HvGetCell(Hive, IndexCell);
            if (!Index)
            {
                /* Shouldn't happen */
                ASSERT(FALSE);
            }
 
            /* Mark the index as a root, and set the index cell */
            Index->Signature = CM_KEY_INDEX_ROOT;
            Index->Count = 1;
            Index->List[0] = KeyNode->SubKeyLists[Type];
            KeyNode->SubKeyLists[Type] = IndexCell;
        }
    }
 
    /* Now we can choose the leaf cell */
    LeafCell = KeyNode->SubKeyLists[Type];
 
    /* Check if we turned the index into a root */
    if (Index->Signature == CM_KEY_INDEX_ROOT)
    {
        DPRINT("Leaf->Root Index Conversion\n");
 
        /* Get the leaf where to add the new entry (the routine will do
         * the splitting if necessary)
         */
        LeafCell = CmpSelectLeaf(Hive, KeyNode, &Name, Type, &RootPointer);
        if (LeafCell == HCELL_NIL)
        {
            /* Not handled */
            ASSERT(FALSE);
        }
    }
 
    /* Add our leaf cell */
    LeafCell = CmpAddToLeaf(Hive, LeafCell, Child, &Name);
    if (LeafCell == HCELL_NIL)
    {
        /* Not handled */
        ASSERT(FALSE);
    }
 
    /* Update the key counts */
    KeyNode->SubKeyCounts[Type]++;
 
    /* Check if caller wants us to return the leaf */
    if (RootPointer)
    {
        /* Return it */
        *RootPointer = LeafCell;
    }
    else
    {
        /* Otherwise, mark it as the list index for the cell */
        KeyNode->SubKeyLists[Type] = LeafCell;
    }
 
    /* If the name was compressed, free our copy */
    if (IsCompressed) Hive->Free(Name.Buffer, 0);
 
    /* Release all our cells */
    if (IndexCell != HCELL_NIL) HvReleaseCell(Hive, IndexCell);
    if (CellToRelease != HCELL_NIL) HvReleaseCell(Hive, CellToRelease);
    HvReleaseCell(Hive, Parent);
    return TRUE;
}

Referenced by CmiAddSubKey(), CmpCreateLinkNode(), CmpDeepCopyKeyInternal(), and CmpDoCreate().

CmpAddValueToList()

NTSTATUS NTAPI CmpAddValueToList	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	ValueCell,
		IN ULONG	Index,
		IN HSTORAGE_TYPE	StorageType,
		IN OUT PCHILD_LIST	ChildList
	)

Definition at line 207 of file cmvalue.c.

{
    HCELL_INDEX ListCell;
    ULONG ChildCount, Length, i;
    PCELL_DATA CellData;
    PAGED_CODE();
 
    /* Sanity check */
    ASSERT((((LONG)Index) >= 0) && (Index <= ChildList->Count));
 
    /* Get the number of entries in the child list */
    ChildCount = ChildList->Count;
    ChildCount++;
    if (ChildCount > 1)
    {
        ASSERT(ChildList->List != HCELL_NIL);
 
        /* The cell should be dirty at this point */
        ASSERT(HvIsCellDirty(Hive, ChildList->List));
 
        /* Check if we have less then 100 children */
        if (ChildCount < 100)
        {
            /* Allocate just enough as requested */
            Length = ChildCount * sizeof(HCELL_INDEX);
        }
        else
        {
            /* Otherwise, we have quite a few, so allocate a batch */
            Length = ROUND_UP(ChildCount, 100) * sizeof(HCELL_INDEX);
            if (Length > HBLOCK_SIZE)
            {
                /* But make sure we don't allocate beyond our block size */
                Length = ROUND_UP(Length, HBLOCK_SIZE);
            }
        }
 
        /* Perform the allocation */
        ListCell = HvReallocateCell(Hive, ChildList->List, Length);
    }
    else
    {
        /* This is our first child, so allocate a single cell */
        ASSERT(ChildList->List == HCELL_NIL);
        ListCell = HvAllocateCell(Hive, sizeof(HCELL_INDEX), StorageType, HCELL_NIL);
    }
 
    /* Fail if we couldn't get a cell */
    if (ListCell == HCELL_NIL) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Set this cell as the child list's list cell */
    ChildList->List = ListCell;
 
    /* Get the actual key list memory */
    CellData = HvGetCell(Hive, ListCell);
    ASSERT(CellData != NULL);
 
    /* Loop all the children */
    for (i = ChildCount - 1; i > Index; i--)
    {
        /* Move them all down */
        CellData->u.KeyList[i] = CellData->u.KeyList[i - 1];
    }
 
    /* Insert us on top now */
    CellData->u.KeyList[Index] = ValueCell;
    ChildList->Count = ChildCount;
 
    /* Release the list cell and make sure the value cell is dirty */
    HvReleaseCell(Hive, ListCell);
    ASSERT(HvIsCellDirty(Hive, ValueCell));
 
    /* We're done here */
    return STATUS_SUCCESS;
}

Referenced by CmiAddValueKey(), CmpCopyKeyValueList(), and CmpSetValueKeyNew().

CmpAllocate()

PVOID NTAPI CmpAllocate	(	IN SIZE_T	Size,
		IN BOOLEAN	Paged,
		IN ULONG	Tag
	)

Definition at line 49 of file registry.c.

{
    UNREFERENCED_PARAMETER(Paged);
    return FrLdrHeapAlloc(Size, Tag);
}

Referenced by CmiInitializeHive(), and RegInitializeHive().

CmpCompareCompressedName()

LONG NTAPI CmpCompareCompressedName	(	IN PCUNICODE_STRING	SearchName,
		IN PWCHAR	CompressedName,
		IN ULONG	NameLength
	)

Definition at line 109 of file cmname.c.

{
    WCHAR* p;
    UCHAR* pp;
    WCHAR chr1, chr2;
    USHORT SearchLength;
    LONG Result;
 
    /* Set the pointers and length and then loop */
    p = SearchName->Buffer;
    pp = (PUCHAR)CompressedName;
    SearchLength = (SearchName->Length / sizeof(WCHAR));
    while (SearchLength > 0 && NameLength > 0)
    {
        /* Get the characters */
        chr1 = *p++;
        chr2 = (WCHAR)(*pp++);
 
        /* Check if we have a direct match */
        if (chr1 != chr2)
        {
            /* See if they match and return result if they don't */
            Result = (LONG)RtlUpcaseUnicodeChar(chr1) -
                     (LONG)RtlUpcaseUnicodeChar(chr2);
            if (Result) return Result;
        }
 
        /* Next chars */
        SearchLength--;
        NameLength--;
    }
 
    /* Return the difference directly */
    return SearchLength - NameLength;
}

Referenced by CmpCompareSubkeys(), CmpDoCompareKeyName(), CmpFindNameInList(), CmpFindValueByNameFromCache(), CmpGetNameControlBlock(), and CmpValidateLexicalOrder().

CmpCompressedNameSize()

USHORT NTAPI CmpCompressedNameSize	(	IN PWCHAR	Name,
		IN ULONG	Length
	)

Definition at line 95 of file cmname.c.

{
    /*
     * Don't remove this: compressed names are "opaque" and just because
     * the current implementation turns them into ansi-names doesn't mean
     * that it will remain that way forever, so -never- assume this code
     * below internally!
     */
    return (USHORT)Length * sizeof(WCHAR);
}

Referenced by BiEnumerateSubKeys(), CmpAddDriverToList(), CmpAddSubKey(), CmpConstructName(), CmpGetHiveName(), CmpIsSafe(), CmpMarkIndexDirty(), CmpQueryKeyData(), CmpQueryKeyDataFromCache(), CmpQueryKeyValueData(), CmpQueryNameInformation(), and CmpRemoveSubKey().

CmpComputeHashKey()

ULONG NTAPI CmpComputeHashKey	(	IN ULONG	Hash,
		IN PCUNICODE_STRING	Name,
		IN BOOLEAN	AllowSeparators
	)

Definition at line 460 of file cmindex.c.

{
    LPWSTR Cp;
    ULONG Value, i;
 
    /* Make some sanity checks on our parameters */
    ASSERT((Name->Length == 0) ||
           (AllowSeparators) ||
           (Name->Buffer[0] != OBJ_NAME_PATH_SEPARATOR));
 
    /* If the name is empty, there is nothing to hash! */
    if (!Name->Length) return Hash;
 
    /* Set the buffer and loop every character */
    Cp = Name->Buffer;
    for (i = 0; i < Name->Length; i += sizeof(WCHAR), Cp++)
    {
        /* Make sure we don't have a separator when we shouldn't */
        ASSERT(AllowSeparators || (*Cp != OBJ_NAME_PATH_SEPARATOR));
 
        /* Check what kind of char we have */
        if (*Cp >= L'a')
        {
            /* In the lower case region... is it truly lower case? */
            if (*Cp < L'z')
            {
                /* Yes! Calculate it ourselves! */
                Value = *Cp - L'a' + L'A';
            }
            else
            {
                /* No, use the API */
                Value = RtlUpcaseUnicodeChar(*Cp);
            }
        }
        else
        {
            /* Reuse the char, it's already upcased */
            Value = *Cp;
        }
 
        /* Multiply by a prime and add our value */
        Hash *= 37;
        Hash += Value;
    }
 
    /* Return the hash */
    return Hash;
}

Referenced by CmpAddToLeaf(), and CmpFindSubKeyByHash().

CmpCopyCompressedName()

VOID NTAPI CmpCopyCompressedName	(	OUT PWCHAR	Destination,
		IN ULONG	DestinationLength,
		IN PWCHAR	Source,
		IN ULONG	SourceLength
	)

Definition at line 56 of file cmname.c.

{
    ULONG i, Length;
 
    /* Get the actual length to copy */
    Length = min(DestinationLength / sizeof(WCHAR), SourceLength);
    for (i = 0; i < Length; i++)
    {
        /* Copy each character */
        Destination[i] = (WCHAR)((PUCHAR)Source)[i];
    }
}

Referenced by BiEnumerateSubKeys(), CmpAddDriverToList(), CmpAddSubKey(), CmpGetHiveName(), CmpIsSafe(), CmpMarkIndexDirty(), CmpQueryKeyData(), CmpQueryKeyValueData(), CmpQueryNameInformation(), and CmpRemoveSubKey().

CmpCopyKeyValueList()

NTSTATUS NTAPI CmpCopyKeyValueList	(	IN PHHIVE	SourceHive,
		IN PCHILD_LIST	SrcValueList,
		IN PHHIVE	DestinationHive,
		IN OUT PCHILD_LIST	DestValueList,
		IN HSTORAGE_TYPE	StorageType
	)

Definition at line 521 of file cmvalue.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PCELL_DATA SrcListData = NULL, DestListData = NULL;
    HCELL_INDEX NewValue;
    ULONG Index;
 
    PAGED_CODE();
 
    /* Reset the destination value list */
    DestValueList->Count = 0;
    DestValueList->List = HCELL_NIL;
 
    /* Check if the list is empty */
    if (!SrcValueList->Count)
        return STATUS_SUCCESS;
 
    /* Get the source value list */
    SrcListData = HvGetCell(SourceHive, SrcValueList->List);
    ASSERT(SrcListData);
 
    /* Copy the actual values */
    for (Index = 0; Index < SrcValueList->Count; Index++)
    {
        NewValue = CmpCopyValue(SourceHive,
                                SrcListData->u.KeyList[Index],
                                DestinationHive,
                                StorageType);
        if (NewValue == HCELL_NIL)
        {
            /* Not enough storage space, stop there and cleanup afterwards */
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
 
        /* Add this value cell to the child list */
        Status = CmpAddValueToList(DestinationHive,
                                   NewValue,
                                   Index,
                                   StorageType,
                                   DestValueList);
        if (!NT_SUCCESS(Status))
        {
            /* Not enough storage space, stop there */
 
            /* Cleanup the newly-created value here, the other ones will be cleaned up afterwards */
            if (!CmpFreeValue(DestinationHive, NewValue))
                HvFreeCell(DestinationHive, NewValue);
            break;
        }
    }
 
    /* Revert-cleanup if failure */
    if (!NT_SUCCESS(Status) && (DestValueList->List != HCELL_NIL))
    {
        /* Do not use CmpRemoveValueFromList but directly delete the data */
 
        /* Get the destination value list */
        DestListData = HvGetCell(DestinationHive, DestValueList->List);
        ASSERT(DestListData);
 
        /* Delete each copied value */
        while (Index--)
        {
            NewValue = DestListData->u.KeyList[Index];
            if (!CmpFreeValue(DestinationHive, NewValue))
                HvFreeCell(DestinationHive, NewValue);
        }
 
        /* Release and free the list */
        HvReleaseCell(DestinationHive, DestValueList->List);
        HvFreeCell(DestinationHive, DestValueList->List);
 
        DestValueList->Count = 0;
        DestValueList->List = HCELL_NIL;
    }
 
    /* Release the cells */
    HvReleaseCell(SourceHive, SrcValueList->List);
 
    return Status;
}

Referenced by CmpDeepCopyKeyInternal().

CmpCopyName()

USHORT NTAPI CmpCopyName	(	IN PHHIVE	Hive,
		OUT PWCHAR	Destination,
		IN PCUNICODE_STRING	Source
	)

Definition at line 21 of file cmname.c.

{
    ULONG i;
 
    /* Check for old hives */
    if (Hive->Version == 1)
    {
        /* Just copy the source directly */
        RtlCopyMemory(Destination, Source->Buffer, Source->Length);
        return Source->Length;
    }
 
    /* For new versions, check for compressed name */
    for (i = 0; i < (Source->Length / sizeof(WCHAR)); i++)
    {
        /* Check if the name is non compressed */
        if (Source->Buffer[i] > (UCHAR)-1)
        {
            /* Do the copy */
            RtlCopyMemory(Destination, Source->Buffer, Source->Length);
            return Source->Length;
        }
 
        /* Copy this character */
        ((PCHAR)Destination)[i] = (CHAR)(Source->Buffer[i]);
    }
 
    /* Compressed name, return length */
    return Source->Length / sizeof(WCHAR);
}

Referenced by CmCreateRootNode(), CmiAddValueKey(), CmiCreateSubKey(), CmpCreateLinkNode(), CmpCreateRootNode(), CmpDoCreateChild(), and CmpSetValueKeyNew().

CmpFindNameInList()

BOOLEAN NTAPI CmpFindNameInList	(	IN PHHIVE	Hive,
		IN PCHILD_LIST	ChildList,
		IN PCUNICODE_STRING	Name,
		OUT PULONG ChildIndex	OPTIONAL,
		OUT PHCELL_INDEX	CellIndex
	)

Definition at line 149 of file cmname.c.

{
    PCELL_DATA CellData;
    HCELL_INDEX CellToRelease = HCELL_NIL;
    ULONG i;
    PCM_KEY_VALUE KeyValue;
    LONG Result;
    UNICODE_STRING SearchName;
    BOOLEAN Success;
 
    /* Make sure there's actually something on the list */
    if (ChildList->Count != 0)
    {
        /* Get the cell data */
        CellData = (PCELL_DATA)HvGetCell(Hive, ChildList->List);
        if (!CellData)
        {
            /* Couldn't get the cell... tell the caller */
            *CellIndex = HCELL_NIL;
            return FALSE;
        }
 
        /* Now loop every entry */
        for (i = 0; i < ChildList->Count; i++)
        {
            /* Check if we have a cell to release */
            if (CellToRelease != HCELL_NIL)
            {
                /* Release it */
                HvReleaseCell(Hive, CellToRelease);
                CellToRelease = HCELL_NIL;
            }
 
            /* Get this value */
            KeyValue = (PCM_KEY_VALUE)HvGetCell(Hive, CellData->u.KeyList[i]);
            if (!KeyValue)
            {
                /* Return with no data found */
                *CellIndex = HCELL_NIL;
                Success = FALSE;
                goto Return;
            }
 
            /* Save the cell to release */
            CellToRelease = CellData->u.KeyList[i];
 
            /* Check if it's a compressed value name */
            if (KeyValue->Flags & VALUE_COMP_NAME)
            {
                /* Compare compressed names */
                Result = CmpCompareCompressedName(Name,
                                                  KeyValue->Name,
                                                  KeyValue->NameLength);
            }
            else
            {
                /* Compare the Unicode name directly */
                SearchName.Length = KeyValue->NameLength;
                SearchName.MaximumLength = SearchName.Length;
                SearchName.Buffer = KeyValue->Name;
                Result = RtlCompareUnicodeString(Name, &SearchName, TRUE);
            }
 
            /* Check if we found it */
            if (!Result)
            {
                /* We did... return info to caller */
                if (ChildIndex) *ChildIndex = i;
                *CellIndex = CellData->u.KeyList[i];
 
                /* Set success state */
                Success = TRUE;
                goto Return;
            }
        }
 
        /* Got to the end of the list */
        if (ChildIndex) *ChildIndex = i;
        *CellIndex = HCELL_NIL;
 
        /* Nothing found if we got here */
        Success = TRUE;
        goto Return;
    }
 
    /* Nothing found... check if the caller wanted more info */
    ASSERT(ChildList->Count == 0);
    if (ChildIndex) *ChildIndex = 0;
    *CellIndex = HCELL_NIL;
 
    /* Nothing found if we got here */
    return TRUE;
 
Return:
    /* Release the first cell we got */
    if (CellData) HvReleaseCell(Hive, ChildList->List);
 
    /* Release the secondary one, if we have one */
    if (CellToRelease) HvReleaseCell(Hive, CellToRelease);
    return Success;
}

Referenced by BiGetRegistryValue(), CmDeleteValueKey(), CmpFindValueByName(), CmSetValueKey(), RegDeleteValueW(), and RegSetValueExW().

CmpFindSubKeyByName()

HCELL_INDEX NTAPI CmpFindSubKeyByName	(	IN PHHIVE	Hive,
		IN PCM_KEY_NODE	Parent,
		IN PCUNICODE_STRING	SearchName
	)

Definition at line 683 of file cmindex.c.

{
    ULONG i;
    PCM_KEY_INDEX IndexRoot;
    HCELL_INDEX SubKey, CellToRelease;
    ULONG Found;
 
    /* Loop each storage type */
    for (i = 0; i < Hive->StorageTypeCount; i++)
    {
        /* Make sure the parent node has subkeys */
        if (Parent->SubKeyCounts[i])
        {
            /* Get the Index */
            IndexRoot = (PCM_KEY_INDEX)HvGetCell(Hive, Parent->SubKeyLists[i]);
            if (!IndexRoot) return HCELL_NIL;
 
            /* Get the cell we'll need to release */
            CellToRelease = Parent->SubKeyLists[i];
 
            /* Check if this is another index root */
            if (IndexRoot->Signature == CM_KEY_INDEX_ROOT)
            {
                /* Lookup the name in the root */
                Found = CmpFindSubKeyInRoot(Hive,
                                            IndexRoot,
                                            SearchName,
                                            &SubKey);
 
                /* Release the previous cell */
                ASSERT(CellToRelease != HCELL_NIL);
                HvReleaseCell(Hive, CellToRelease);
 
                /* Make sure we found something valid */
                if (Found & INVALID_INDEX) break;
 
                /* Get the new Index Root and set the new cell to be released */
                if (SubKey == HCELL_NIL) continue;
                CellToRelease = SubKey;
                IndexRoot = (PCM_KEY_INDEX)HvGetCell(Hive, SubKey);
            }
 
            /* Make sure the signature is what we expect it to be */
            ASSERT((IndexRoot->Signature == CM_KEY_INDEX_LEAF) ||
                   (IndexRoot->Signature == CM_KEY_FAST_LEAF) ||
                   (IndexRoot->Signature == CM_KEY_HASH_LEAF));
 
            /* Check if this isn't a hashed leaf */
            if (IndexRoot->Signature != CM_KEY_HASH_LEAF)
            {
                /* Find the subkey in the leaf */
                Found = CmpFindSubKeyInLeaf(Hive,
                                            IndexRoot,
                                            SearchName,
                                            &SubKey);
 
                /* Release the previous cell */
                ASSERT(CellToRelease != HCELL_NIL);
                HvReleaseCell(Hive, CellToRelease);
 
                /* Make sure we found a valid index */
                if (Found & INVALID_INDEX) break;
            }
            else
            {
                /* Find the subkey in the hash */
                SubKey = CmpFindSubKeyByHash(Hive,
                                             (PCM_KEY_FAST_INDEX)IndexRoot,
                                             SearchName);
 
                /* Release the previous cell */
                ASSERT(CellToRelease != HCELL_NIL);
                HvReleaseCell(Hive, CellToRelease);
            }
 
            /* Make sure we got a valid subkey and return it */
            if (SubKey != HCELL_NIL) return SubKey;
        }
    }
 
    /* If we got here, then we failed */
    return HCELL_NIL;
}

Referenced by BiLoadHive(), BiOpenKey(), CmGetSystemControlValues(), CmpDoCreate(), CmpFindControlSet(), CmpFindDrivers(), CmpIsSafe(), CmpParseKey(), CmpSortDriverList(), CmpWalkPath(), RegOpenKey(), and RegpCreateOrOpenKey().

CmpFindSubKeyByNumber()

HCELL_INDEX NTAPI CmpFindSubKeyByNumber	(	IN PHHIVE	Hive,
		IN PCM_KEY_NODE	Node,
		IN ULONG	Number
	)

Definition at line 600 of file cmindex.c.

{
    PCM_KEY_INDEX Index;
    HCELL_INDEX Result = HCELL_NIL;
 
    /* Check if it's in the stable list */
    if (Number < Node->SubKeyCounts[Stable])
    {
        /* Get the actual key index */
        Index = (PCM_KEY_INDEX)HvGetCell(Hive, Node->SubKeyLists[Stable]);
        if (!Index) return HCELL_NIL;
 
        /* Do a search inside it */
        Result = CmpDoFindSubKeyByNumber(Hive, Index, Number);
 
        /* Release the cell and return the result */
        HvReleaseCell(Hive, Node->SubKeyLists[Stable]);
        return Result;
    }
    else if (Hive->StorageTypeCount > Volatile)
    {
        /* It's in the volatile list */
        Number = Number - Node->SubKeyCounts[Stable];
        if (Number < Node->SubKeyCounts[Volatile])
        {
            /* Get the actual key index */
            Index = (PCM_KEY_INDEX)HvGetCell(Hive, Node->SubKeyLists[Volatile]);
            if (!Index) return HCELL_NIL;
 
            /* Do a search inside it */
            Result = CmpDoFindSubKeyByNumber(Hive, Index, Number);
 
            /* Release the cell and return the result */
            HvReleaseCell(Hive, Node->SubKeyLists[Volatile]);
            return Result;
        }
    }
 
    /* Nothing was found */
    return HCELL_NIL;
}

Referenced by BiEnumerateSubKeys(), CmEnumerateKey(), CmpDeepCopyKeyInternal(), CmpFindDrivers(), and CmpValidateRegistryInternal().

CmpFindValueByName()

HCELL_INDEX NTAPI CmpFindValueByName	(	IN PHHIVE	Hive,
		IN PCM_KEY_NODE	KeyNode,
		IN PCUNICODE_STRING	Name
	)

Definition at line 99 of file cmvalue.c.

{
    HCELL_INDEX CellIndex;
 
    /* Call the main function */
    if (!CmpFindNameInList(Hive,
                           &KeyNode->ValueList,
                           Name,
                           NULL,
                           &CellIndex))
    {
        /* Sanity check */
        ASSERT(CellIndex == HCELL_NIL);
    }
 
    /* Return the index */
    return CellIndex;
}

Referenced by CmGetSystemControlValues(), CmpAddDriverToList(), CmpFindControlSet(), CmpFindTagIndex(), CmpGetSymbolicLink(), CmpIsLoadType(), CmpIsSafe(), CmpSortDriverList(), RegQueryValue(), and RegQueryValueExW().

CmpFree()

VOID NTAPI CmpFree	(	IN PVOID	Ptr,
		IN ULONG	Quota
	)

Definition at line 60 of file registry.c.

{
    UNREFERENCED_PARAMETER(Quota);
    FrLdrHeapFree(Ptr, 0);
}

Referenced by CmiInitializeHive(), and RegInitializeHive().

CmpFreeKeyByCell()

NTSTATUS NTAPI CmpFreeKeyByCell	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell,
		IN BOOLEAN	Unlink
	)

Definition at line 159 of file cmkeydel.c.

{
    PCM_KEY_NODE CellData, ParentData;
    PCELL_DATA ListData;
    ULONG i;
    BOOLEAN Result;
 
    /* Mark the entire key dirty */
    CmpMarkKeyDirty(Hive, Cell, TRUE);
 
    /* Get the target node and release it */
    CellData = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
    ASSERT(CellData);
    HvReleaseCell(Hive, Cell);
 
    /* Make sure we don't have subkeys */
    ASSERT(CellData->SubKeyCounts[Stable] + CellData->SubKeyCounts[Volatile] == 0);
 
    /* Check if we have to unlink */
    if (Unlink)
    {
        /* Remove the subkey */
        Result = CmpRemoveSubKey(Hive, CellData->Parent, Cell);
        if (!Result) return STATUS_INSUFFICIENT_RESOURCES;
 
        /* Get the parent node and release it */
        ParentData = (PCM_KEY_NODE)HvGetCell(Hive, CellData->Parent);
        ASSERT(ParentData);
        HvReleaseCell(Hive, CellData->Parent);
 
        /* Check if the parent node has no more subkeys */
        if (ParentData->SubKeyCounts[Stable] + ParentData->SubKeyCounts[Volatile] == 0)
        {
            /* Then free the cached name/class lengths */
            ParentData->MaxNameLen  = 0;
            ParentData->MaxClassLen = 0;
        }
    }
 
    // TODO: Handle predefined keys (Flags: KEY_PREDEF_HANDLE)
    /* If this is an exit node, we don't have values */
    if (!(CellData->Flags & KEY_HIVE_EXIT))
    {
        /* Check if we have any values */
        if (CellData->ValueList.Count > 0)
        {
            /* Get the value list and release it */
            ListData = HvGetCell(Hive, CellData->ValueList.List);
            ASSERT(ListData);
            HvReleaseCell(Hive, CellData->ValueList.List);
 
            /* Loop every value */
            for (i = 0; i < CellData->ValueList.Count; i++)
            {
                /* Free it */
                Result = CmpFreeValue(Hive, ListData->u.KeyList[i]);
                ASSERT(Result);
            }
 
            /* Free the value list */
            HvFreeCell(Hive, CellData->ValueList.List);
        }
 
        /* Free the key security descriptor */
        CmpFreeSecurityDescriptor(Hive, Cell);
    }
 
    /* Free the key body itself, and then return our status */
    if (!CmpFreeKeyBody(Hive, Cell)) return STATUS_INSUFFICIENT_RESOURCES;
    return STATUS_SUCCESS;
}

Referenced by BiDeleteKey(), CmDeleteKey(), CmpDoCreate(), CmpUnlinkHiveFromMaster(), and RegDeleteKeyW().

CmpFreeSecurityDescriptor()

VOID NTAPI CmpFreeSecurityDescriptor	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell
	)

Definition at line 65 of file cmse.c.

{
    PCM_KEY_NODE CellData;
    PCM_KEY_SECURITY SecurityData;
 
    PAGED_CODE();
 
    // ASSERT( (((PCMHIVE)Hive)->HiveSecurityLockOwner == KeGetCurrentThread()) || (CmpTestRegistryLockExclusive() == TRUE) );
 
    CellData = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
    if (!CellData) return;
 
    ASSERT(CellData->Signature == CM_KEY_NODE_SIGNATURE);
 
    // FIXME: ReactOS-specific: check whether this key has a security block.
    // On Windows there is no such check, all keys seem to have a valid
    // security block.
    // If we remove this check on ReactOS (and continue running) then we get
    // a BSOD at the end...
    if (CellData->Security == HCELL_NIL)
    {
        DPRINT("Cell 0x%08x (data 0x%p) has no security block!\n", Cell, CellData);
        HvReleaseCell(Hive, Cell);
        return;
    }
 
    SecurityData = (PCM_KEY_SECURITY)HvGetCell(Hive, CellData->Security);
    if (!SecurityData)
    {
        HvReleaseCell(Hive, Cell);
        return;
    }
 
    ASSERT(SecurityData->Signature == CM_KEY_SECURITY_SIGNATURE);
 
    if (SecurityData->ReferenceCount > 1)
    {
        SecurityData->ReferenceCount--;
    }
    else // if (SecurityData->ReferenceCount <= 1)
    {
        CmpRemoveSecurityCellList(Hive, CellData->Security);
        HvFreeCell(Hive, CellData->Security);
    }
 
    CellData->Security = HCELL_NIL;
    HvReleaseCell(Hive, CellData->Security);
    HvReleaseCell(Hive, Cell);
}

Referenced by CmpFreeKeyByCell().

CmpFreeValue()

BOOLEAN NTAPI CmpFreeValue	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell
	)

Definition at line 73 of file cmvalue.c.

{
    PCM_KEY_VALUE Value;
    PAGED_CODE();
 
    /* Get the cell data */
    Value = (PCM_KEY_VALUE)HvGetCell(Hive, Cell);
    if (!Value) ASSERT(FALSE);
 
    /* Free it */
    if (!CmpFreeValueData(Hive, Value->Data, Value->DataLength))
    {
        /* We failed to free the data, return failure */
        HvReleaseCell(Hive, Cell);
        return FALSE;
    }
 
    /* Release the cell and free it */
    HvReleaseCell(Hive, Cell);
    HvFreeCell(Hive, Cell);
    return TRUE;
}

Referenced by CmDeleteValueKey(), CmiAddValueKey(), CmpCopyKeyValueList(), CmpFreeKeyByCell(), CmpSetValueKeyNew(), and RegDeleteValueW().

CmpFreeValueData()

BOOLEAN NTAPI CmpFreeValueData	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	DataCell,
		IN ULONG	DataLength
	)

Definition at line 44 of file cmvalue.c.

{
    ULONG KeySize;
    PAGED_CODE();
 
    /* If this is a small key, the data is built-in */
    if (!CmpIsKeyValueSmall(&KeySize, DataLength))
    {
        /* If there's no data cell, there's nothing to do */
        if (DataCell == HCELL_NIL) return TRUE;
 
        /* Make sure the data cell is allocated */
        //ASSERT(HvIsCellAllocated(Hive, DataCell));
 
        /* Unsupported value type */
        ASSERT_VALUE_BIG(Hive, KeySize);
 
        /* Normal value, just free the data cell */
        HvFreeCell(Hive, DataCell);
    }
 
    /* Operation complete */
    return TRUE;
}

Referenced by CmpFreeValue(), and CmpSetValueKeyExisting().

CmpGetValueData()

BOOLEAN NTAPI CmpGetValueData	(	IN PHHIVE	Hive,
		IN PCM_KEY_VALUE	Value,
		OUT PULONG	Length,
		OUT PVOID *	Buffer,
		OUT PBOOLEAN	BufferAllocated,
		OUT PHCELL_INDEX	CellToRelease
	)

Definition at line 125 of file cmvalue.c.

{
    PAGED_CODE();
 
    /* Sanity check */
    ASSERT(Value->Signature == CM_KEY_VALUE_SIGNATURE);
 
    /* Set failure defaults */
    *BufferAllocated = FALSE;
    *Buffer = NULL;
    *CellToRelease = HCELL_NIL;
 
    /* Check if this is a small key */
    if (CmpIsKeyValueSmall(Length, Value->DataLength))
    {
        /* Return the data immediately */
        *Buffer = &Value->Data;
        return TRUE;
    }
 
    /* Unsupported at the moment */
    ASSERT_VALUE_BIG(Hive, *Length);
 
    /* Get the data from the cell */
    *Buffer = HvGetCell(Hive, Value->Data);
    if (!(*Buffer)) return FALSE;
 
    /* Return success and the cell to be released */
    *CellToRelease = Value->Data;
    return TRUE;
}

Referenced by CmpFindTagIndex(), CmpGetSymbolicLink(), CmpGetValueDataFromCache(), and CmpValueToData().

CmpIsKeyValueBig()

static BOOLEAN CmpIsKeyValueBig ( IN PHHIVE  Hive, IN ULONG  Length  )

inlinestatic

Definition at line 416 of file cmlib.h.

{
    /* Check if the hive is XP Beta 1 or newer */
    if (Hive->Version >= HSYS_WHISTLER_BETA1)
    {
        /* Check if the key length is valid for a big value key */
        if ((Length < CM_KEY_VALUE_SPECIAL_SIZE) && (Length > CM_KEY_VALUE_BIG))
        {
            /* Yes, this value is big */
            return TRUE;
        }
    }
 
    /* Not a big value key */
    return FALSE;
}

CmpIsKeyValueSmall()

static BOOLEAN CmpIsKeyValueSmall ( OUT PULONG  RealLength, IN ULONG  Length  )

inlinestatic

Definition at line 395 of file cmlib.h.

{
    /* Check if the length has the special size value */
    if (Length >= CM_KEY_VALUE_SPECIAL_SIZE)
    {
        /* It does, so this is a small key: return the real length */
        *RealLength = Length - CM_KEY_VALUE_SPECIAL_SIZE;
        return TRUE;
    }
 
    /* This is not a small key, return the length we read */
    *RealLength = Length;
    return FALSE;
}

Referenced by CmGetSystemControlValues(), CmpCopyValue(), CmpFreeValueData(), CmpGetValueData(), CmpMarkValueDataDirty(), CmpQueryKeyValueData(), CmpSetValueKeyExisting(), and CmpValidateValueListByCount().

CmpMarkIndexDirty()

BOOLEAN NTAPI CmpMarkIndexDirty	(	IN PHHIVE	Hive,
		HCELL_INDEX	ParentKey,
		HCELL_INDEX	TargetKey
	)

CmpMarkValueDataDirty()

BOOLEAN NTAPI CmpMarkValueDataDirty	(	IN PHHIVE	Hive,
		IN PCM_KEY_VALUE	Value
	)

Definition at line 19 of file cmvalue.c.

{
    ULONG KeySize;
    PAGED_CODE();
 
    /* Make sure there's actually any data */
    if (Value->Data != HCELL_NIL)
    {
        /* If this is a small key, there's no need to have it dirty */
        if (CmpIsKeyValueSmall(&KeySize, Value->DataLength)) return TRUE;
 
        /* Check if this is a big key */
        ASSERT_VALUE_BIG(Hive, KeySize);
 
        /* Normal value, just mark it dirty */
        HvMarkCellDirty(Hive, Value->Data, FALSE);
    }
 
    /* Operation complete */
    return TRUE;
}

Referenced by CmDeleteValueKey(), CmpMarkKeyDirty(), CmpSetValueKeyExisting(), and RegDeleteValueW().

CmpNameSize()

USHORT NTAPI CmpNameSize	(	IN PHHIVE	Hive,
		IN PCUNICODE_STRING	Name
	)

Definition at line 74 of file cmname.c.

{
    ULONG i;
 
    /* For old hives, just return the length */
    if (Hive->Version == 1) return Name->Length;
 
    /* For new versions, check for compressed name */
    for (i = 0; i < (Name->Length / sizeof(WCHAR)); i++)
    {
        /* Check if the name is non compressed */
        if (Name->Buffer[i] > (UCHAR)-1) return Name->Length;
    }
 
    /* Compressed name, return length */
    return Name->Length / sizeof(WCHAR);
}

Referenced by CmCreateRootNode(), CmiAddValueKey(), CmiCreateSubKey(), CmpCreateLinkNode(), CmpCreateRootNode(), CmpDoCreateChild(), and CmpSetValueKeyNew().

CmpRemoveSecurityCellList()

VOID NTAPI CmpRemoveSecurityCellList	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	SecurityCell
	)

Definition at line 19 of file cmse.c.

{
    PCM_KEY_SECURITY SecurityData, FlinkCell, BlinkCell;
 
    PAGED_CODE();
 
    // ASSERT( (((PCMHIVE)Hive)->HiveSecurityLockOwner == KeGetCurrentThread()) || (CmpTestRegistryLockExclusive() == TRUE) );
 
    SecurityData = (PCM_KEY_SECURITY)HvGetCell(Hive, SecurityCell);
    if (!SecurityData) return;
 
    FlinkCell = (PCM_KEY_SECURITY)HvGetCell(Hive, SecurityData->Flink);
    if (!FlinkCell)
    {
        HvReleaseCell(Hive, SecurityCell);
        return;
    }
 
    BlinkCell = (PCM_KEY_SECURITY)HvGetCell(Hive, SecurityData->Blink);
    if (!BlinkCell)
    {
        HvReleaseCell(Hive, SecurityData->Flink);
        HvReleaseCell(Hive, SecurityCell);
        return;
    }
 
    /* Sanity checks */
    ASSERT(FlinkCell->Blink == SecurityCell);
    ASSERT(BlinkCell->Flink == SecurityCell);
 
    /* Unlink the security block and free it */
    FlinkCell->Blink = SecurityData->Blink;
    BlinkCell->Flink = SecurityData->Flink;
#ifdef USE_CM_CACHE
    CmpRemoveFromSecurityCache(Hive, SecurityCell);
#endif
 
    /* Release the cells */
    HvReleaseCell(Hive, SecurityData->Blink);
    HvReleaseCell(Hive, SecurityData->Flink);
    HvReleaseCell(Hive, SecurityCell);
}

Referenced by CmpFreeSecurityDescriptor().

CmpRemoveSubKey()

BOOLEAN NTAPI CmpRemoveSubKey	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	ParentKey,
		IN HCELL_INDEX	TargetKey
	)

Definition at line 1694 of file cmindex.c.

{
    PCM_KEY_NODE Node;
    UNICODE_STRING SearchName;
    BOOLEAN IsCompressed;
    WCHAR Buffer[50];
    HCELL_INDEX RootCell = HCELL_NIL, LeafCell, ChildCell;
    PCM_KEY_INDEX Root = NULL, Leaf;
    PCM_KEY_FAST_INDEX Child;
    ULONG Storage, RootIndex = INVALID_INDEX, LeafIndex;
    BOOLEAN Result = FALSE;
    HCELL_INDEX CellToRelease1 = HCELL_NIL, CellToRelease2  = HCELL_NIL;
 
    /* Get the target key node */
    Node = (PCM_KEY_NODE)HvGetCell(Hive, TargetKey);
    if (!Node) return FALSE;
 
    /* Make sure it's dirty, then release it */
    ASSERT(HvIsCellDirty(Hive, TargetKey));
    HvReleaseCell(Hive, TargetKey);
 
    /* Check if the name is compressed */
    if (Node->Flags & KEY_COMP_NAME)
    {
        /* Remember for later */
        IsCompressed = TRUE;
 
        /* Build the search name */
        SearchName.Length = CmpCompressedNameSize(Node->Name,
                                                  Node->NameLength);
        SearchName.MaximumLength = SearchName.Length;
 
        /* Do we need an extra bufer? */
        if (SearchName.MaximumLength > sizeof(Buffer))
        {
            /* Allocate one */
            SearchName.Buffer = Hive->Allocate(SearchName.Length, TRUE, TAG_CM);
            if (!SearchName.Buffer) return FALSE;
        }
        else
        {
            /* Otherwise, use our local stack buffer */
            SearchName.Buffer = Buffer;
        }
 
        /* Copy the compressed name */
        CmpCopyCompressedName(SearchName.Buffer,
                              SearchName.MaximumLength,
                              Node->Name,
                              Node->NameLength);
    }
    else
    {
        /* It's not compressed, build the name directly from the node */
        IsCompressed = FALSE;
        SearchName.Length = Node->NameLength;
        SearchName.MaximumLength = Node->NameLength;
        SearchName.Buffer = Node->Name;
    }
 
    /* Now get the parent node */
    Node = (PCM_KEY_NODE)HvGetCell(Hive, ParentKey);
    if (!Node) goto Exit;
 
    /* Make sure it's dirty, then release it */
    ASSERT(HvIsCellDirty(Hive, ParentKey));
    HvReleaseCell(Hive, ParentKey);
 
    /* Get the storage type and make sure it's not empty */
    Storage = HvGetCellType(TargetKey);
    ASSERT(Node->SubKeyCounts[Storage] != 0);
    //ASSERT(HvIsCellAllocated(Hive, Node->SubKeyLists[Storage]));
 
    /* Get the leaf cell now */
    LeafCell = Node->SubKeyLists[Storage];
    Leaf = (PCM_KEY_INDEX)HvGetCell(Hive, LeafCell);
    if (!Leaf) goto Exit;
 
    /* Remember to release it later */
    CellToRelease1 = LeafCell;
 
    /* Check if the leaf is a root */
    if (Leaf->Signature == CM_KEY_INDEX_ROOT)
    {
        /* Find the child inside the root */
        RootIndex = CmpFindSubKeyInRoot(Hive, Leaf, &SearchName, &ChildCell);
        if (RootIndex & INVALID_INDEX) goto Exit;
        ASSERT(ChildCell != FALSE);
 
        /* The root cell is now this leaf */
        Root = Leaf;
        RootCell = LeafCell;
 
        /* And the new leaf is now this child */
        LeafCell = ChildCell;
        Leaf = (PCM_KEY_INDEX)HvGetCell(Hive, LeafCell);
        if (!Leaf) goto Exit;
 
        /* Remember to release it later */
        CellToRelease2 = LeafCell;
    }
 
    /* Make sure the leaf is valid */
    ASSERT((Leaf->Signature == CM_KEY_INDEX_LEAF) ||
           (Leaf->Signature == CM_KEY_FAST_LEAF) ||
           (Leaf->Signature == CM_KEY_HASH_LEAF));
 
    /* Now get the child in the leaf */
    LeafIndex = CmpFindSubKeyInLeaf(Hive, Leaf, &SearchName, &ChildCell);
    if (LeafIndex & INVALID_INDEX) goto Exit;
    ASSERT(ChildCell != HCELL_NIL);
 
    /* Decrement key counts and check if this was the last leaf entry */
    Node->SubKeyCounts[Storage]--;
    if (!(--Leaf->Count))
    {
        /* Free the leaf */
        HvFreeCell(Hive, LeafCell);
 
        /* Check if we were inside a root */
        if (Root)
        {
            /* Decrease the root count too, since the leaf is going away */
            if (!(--Root->Count))
            {
                /* The root is gone too,n ow */
                HvFreeCell(Hive, RootCell);
                Node->SubKeyLists[Storage] = HCELL_NIL;
            }
            else if (RootIndex < Root->Count)
            {
                /* Bring everything up by one */
                RtlMoveMemory(&Root->List[RootIndex],
                              &Root->List[RootIndex + 1],
                              (Root->Count - RootIndex) * sizeof(HCELL_INDEX));
            }
        }
        else
        {
            /* Otherwise, just clear the cell */
            Node->SubKeyLists[Storage] = HCELL_NIL;
        }
    }
    else if (LeafIndex < Leaf->Count)
    {
        /* Was the leaf a normal index? */
        if (Leaf->Signature == CM_KEY_INDEX_LEAF)
        {
            /* Bring everything up by one */
            RtlMoveMemory(&Leaf->List[LeafIndex],
                          &Leaf->List[LeafIndex + 1],
                          (Leaf->Count - LeafIndex) * sizeof(HCELL_INDEX));
        }
        else
        {
            /* This is a fast index, bring everything up by one */
            Child = (PCM_KEY_FAST_INDEX)Leaf;
            RtlMoveMemory(&Child->List[LeafIndex],
                          &Child->List[LeafIndex+1],
                          (Child->Count - LeafIndex) * sizeof(CM_INDEX));
        }
    }
 
    /* If we got here, now we're done */
    Result = TRUE;
 
Exit:
    /* Release any cells we may have been holding */
    if (CellToRelease1 != HCELL_NIL) HvReleaseCell(Hive, CellToRelease1);
    if (CellToRelease2 != HCELL_NIL) HvReleaseCell(Hive, CellToRelease2);
 
    /* Check if the name was compressed and not inside our local buffer */
    if ((IsCompressed) && (SearchName.MaximumLength > sizeof(Buffer)))
    {
        /* Free the buffer we allocated */
        Hive->Free(SearchName.Buffer, 0);
    }
 
    /* Return the result */
    return Result;
}

Referenced by CmpFreeKeyByCell().

CmpRemoveValueFromList()

NTSTATUS NTAPI CmpRemoveValueFromList	(	IN PHHIVE	Hive,
		IN ULONG	Index,
		IN OUT PCHILD_LIST	ChildList
	)

Definition at line 320 of file cmvalue.c.

{
    ULONG Count;
    PCELL_DATA CellData;
    HCELL_INDEX NewCell;
    PAGED_CODE();
 
    /* Sanity check */
    ASSERT((((LONG)Index) >= 0) && (Index <= ChildList->Count));
 
    /* Get the new count after removal */
    Count = ChildList->Count - 1;
    if (Count > 0)
    {
        /* Get the actual list array */
        CellData = HvGetCell(Hive, ChildList->List);
        if (!CellData) return STATUS_INSUFFICIENT_RESOURCES;
 
        /* Make sure cells data have been made dirty */
        ASSERT(HvIsCellDirty(Hive, ChildList->List));
        ASSERT(HvIsCellDirty(Hive, CellData->u.KeyList[Index]));
 
        /* Loop the list */
        while (Index < Count)
        {
            /* Move everything up */
            CellData->u.KeyList[Index] = CellData->u.KeyList[Index + 1];
            Index++;
        }
 
        /* Re-allocate the cell for the list by decreasing the count */
        NewCell = HvReallocateCell(Hive,
                                   ChildList->List,
                                   Count * sizeof(HCELL_INDEX));
        ASSERT(NewCell != HCELL_NIL);
        HvReleaseCell(Hive,ChildList->List);
 
        /* Update the list cell */
        ChildList->List = NewCell;
    }
    else
    {
        /* Otherwise, we were the last entry, so free the list entirely */
        HvFreeCell(Hive, ChildList->List);
        ChildList->List = HCELL_NIL;
    }
 
    /* Update the child list with the new count */
    ChildList->Count = Count;
    return STATUS_SUCCESS;
}

Referenced by CmDeleteValueKey(), and RegDeleteValueW().

CmpRepairClassOfNodeKey()

BOOLEAN CMAPI CmpRepairClassOfNodeKey	(	_Inout_ PHHIVE	Hive,
		_In_ HCELL_INDEX	CurrentCell,
		_Inout_ PCELL_DATA	CellData,
		_In_ BOOLEAN	FixHive
	)

Repairs the class from damage due to class corruption within the node key.

Parameters

[in,out]	Hive	A pointer to a hive descriptor containing faulty data.
[in]	CurrentCell	The current cell to be marked as dirty.
[in,out]	CellData	The cell data of the current cell of which its class is to be repaired.
[in]	FixHive	If set to TRUE, self heal is triggered and the target hive will be fixed. Otherwise the hive will not be fixed.

Returns

Returns TRUE if the function successfully healed the class of node key, FALSE otherwise.

Definition at line 637 of file cmheal.c.

{
    PAGED_CODE();
 
    /* Is self healing possible? */
    if (!CmIsSelfHealEnabled(FixHive))
    {
        DPRINT1("Self healing not possible\n");
        return FALSE;
    }
 
    /*
     * Mark the cell where we got the actual
     * cell data as dirty and fix the class field
     * of key node.
     */
    HvMarkCellDirty(Hive, CurrentCell, FALSE);
    CellData->u.KeyNode.Class = HCELL_NIL;
    CellData->u.KeyNode.ClassLength = 0;
 
    /* Mark the hive as in self healing mode since we repaired it */
    Hive->BaseBlock->BootType |= HBOOT_TYPE_SELF_HEAL;
    return TRUE;
}

Referenced by CmpValidateKey().

CmpRepairKeyNodeSignature()

BOOLEAN CMAPI CmpRepairKeyNodeSignature	(	_Inout_ PHHIVE	Hive,
		_In_ HCELL_INDEX	CurrentCell,
		_Inout_ PCELL_DATA	CellData,
		_In_ BOOLEAN	FixHive
	)

Repairs the key node signature from damage due to signature corruption.

Parameters

[in,out]	Hive	A pointer to a hive descriptor containing faulty data.
[in]	CurrentCell	The current cell to be marked as dirty.
[in,out]	CellData	The cell data of the current cell of which its signature is to be repaired.
[in]	FixHive	If set to TRUE, self heal is triggered and the target hive will be fixed. Otherwise the hive will not be fixed.

Returns

Returns TRUE if the function successfully healed the key node signature, FALSE otherwise.

Definition at line 585 of file cmheal.c.

{
    PAGED_CODE();
 
    /* Is self healing possible? */
    if (!CmIsSelfHealEnabled(FixHive))
    {
        DPRINT1("Self healing not possible\n");
        return FALSE;
    }
 
    /*
     * Mark the cell where we got the actual
     * cell data as dirty and fix the key signature.
     */
    HvMarkCellDirty(Hive, CurrentCell, FALSE);
    CellData->u.KeyNode.Signature = CM_KEY_NODE_SIGNATURE;
 
    /* Mark the hive as in self healing mode since we repaired it */
    Hive->BaseBlock->BootType |= HBOOT_TYPE_SELF_HEAL;
    return TRUE;
}

Referenced by CmpValidateKey().

CmpRepairParentKey()

BOOLEAN CMAPI CmpRepairParentKey	(	_Inout_ PHHIVE	Hive,
		_In_ HCELL_INDEX	TargetKey,
		_In_ HCELL_INDEX	ParentKey,
		_In_ BOOLEAN	FixHive
	)

Repairs the parent key from damage by removing the offending subkey cell.

Parameters

[in,out]	Hive	A pointer to a hive descriptor containing faulty data.
[in]	TargetKey	The offending target cell to remove from the parent.
[in]	ParentKey	The damaged parent key cell to heal.
[in]	FixHive	If set to TRUE, self heal is triggered and the target hive will be fixed. Otherwise the hive will not be fixed.

Returns

Returns TRUE if the function successfully healed the parent key, FALSE otherwise.

Definition at line 409 of file cmheal.c.

{
    PCM_KEY_INDEX KeyIndex;
    PCM_KEY_NODE KeyNode;
    BOOLEAN ParentRepaired;
 
    PAGED_CODE();
 
    /* The target key must NEVER be NIL! */
    ASSERT(TargetKey != HCELL_NIL);
 
    /* Assume the parent hasn't been repaired yet */
    ParentRepaired = FALSE;
 
    /* Is self healing possible? */
    if (!CmIsSelfHealEnabled(FixHive))
    {
        DPRINT1("Self healing not possible\n");
        return ParentRepaired;
    }
 
    /* Obtain a node from the parent */
    KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, ParentKey);
    if (!KeyNode)
    {
        DPRINT1("Couldn't get the parent key node\n");
        return ParentRepaired;
    }
 
    /* Obtain the index as well since we got the parent node */
    KeyIndex = (PCM_KEY_INDEX)HvGetCell(Hive, KeyNode->SubKeyLists[Stable]);
    if (!KeyIndex)
    {
        DPRINT1("Couldn't get the key index from parent node\n");
        HvReleaseCell(Hive, ParentKey);
        return ParentRepaired;
    }
 
    /* Check if this is a root */
    if (KeyIndex->Signature == CM_KEY_INDEX_ROOT)
    {
        /* It is, call the specific helper to discard the damaged key down the root */
        ParentRepaired = CmpRemoveSubkeyInRoot(Hive,
                                               KeyIndex,
                                               TargetKey);
    }
    else if ((KeyIndex->Signature == CM_KEY_INDEX_LEAF) ||
             (KeyIndex->Signature == CM_KEY_FAST_LEAF) ||
             (KeyIndex->Signature == CM_KEY_HASH_LEAF))
    {
        /* Otherwise call the leaf helper */
        ParentRepaired = CmpRemoveSubKeyInLeaf(Hive,
                                               KeyNode,
                                               KeyIndex,
                                               TargetKey);
    }
    else
    {
        /*
         * Generally CmCheckRegistry detects if a key index
         * in the subkeys list is totally broken (we understand
         * that if its signature is not root or leaf) and it will
         * purge the whole subkeys list in such cases. With that
         * being said, we should never reach this code path. But
         * if for whatever reason we reach here then something
         * is seriously wrong.
         */
        DPRINT1("The key index signature is invalid (KeyIndex->Signature == %lu)", KeyIndex->Signature);
        ASSERT(FALSE);
    }
 
    /*
     * If we successfully removed the offending key
     * cell mark down the parent as dirty and punt down
     * the subkey count as well. Mark the hive as in
     * self heal mode as well.
     */
    if (ParentRepaired)
    {
        HvMarkCellDirty(Hive, ParentKey, FALSE);
        KeyNode->SubKeyCounts[Stable]--;
        Hive->BaseBlock->BootType |= HBOOT_TYPE_SELF_HEAL;
        DPRINT1("The subkey has been removed, the parent is now repaired\n");
    }
 
    HvReleaseCell(Hive, KeyNode->SubKeyLists[Stable]);
    HvReleaseCell(Hive, ParentKey);
    return ParentRepaired;
}

Referenced by CmpValidateRegistryInternal().

CmpRepairParentNode()

BOOLEAN CMAPI CmpRepairParentNode	(	_Inout_ PHHIVE	Hive,
		_In_ HCELL_INDEX	CurrentCell,
		_In_ HCELL_INDEX	ParentCell,
		_Inout_ PCELL_DATA	CellData,
		_In_ BOOLEAN	FixHive
	)

Repairs the parent of the node from damage due to parent cell and parent node incosistency.

Parameters

[in,out]	Hive	A pointer to a hive descriptor containing faulty data.
[in]	CurrentCell	The current cell to be marked as dirty.
[in]	ParentCell	The sane parent cell which is used by the function for new parent node assignment.
[in,out]	CellData	The cell data of the current cell of which its parent node is to be repaired.
[in]	FixHive	If set to TRUE, self heal is triggered and the target hive will be fixed. Otherwise the hive will not be fixed.

Returns

Returns TRUE if the function successfully healed the parent node, FALSE otherwise.

Definition at line 532 of file cmheal.c.

{
    PAGED_CODE();
 
    /* Is self healing possible? */
    if (!CmIsSelfHealEnabled(FixHive))
    {
        DPRINT1("Self healing not possible\n");
        return FALSE;
    }
 
    /*
     * Mark the cell where we got the actual
     * cell data as dirty and fix the node.
     */
    HvMarkCellDirty(Hive, CurrentCell, FALSE);
    CellData->u.KeyNode.Parent = ParentCell;
 
    /* Mark the hive as in self healing mode since we repaired it */
    Hive->BaseBlock->BootType |= HBOOT_TYPE_SELF_HEAL;
    return TRUE;
}

Referenced by CmpValidateKey().

CmpRepairSubKeyCounts()

BOOLEAN CMAPI CmpRepairSubKeyCounts	(	_Inout_ PHHIVE	Hive,
		_In_ HCELL_INDEX	CurrentCell,
		_In_ ULONG	Count,
		_Inout_ PCELL_DATA	CellData,
		_In_ BOOLEAN	FixHive
	)

Repairs the subkey list count due to corruption. The process involves by fixing the count itself with a sane count.

Parameters

[in,out]	Hive	A pointer to a hive descriptor containing faulty data.
[in]	CurrentCell	The current cell to be marked as dirty.
[in]	Count	The healthy count which is used by the function to fix the subkeys list count.
[in,out]	CellData	The cell data of the current cell of which its subkeys list is to be fixed.
[in]	FixHive	If set to TRUE, self heal is triggered and the target hive will be fixed. Otherwise the hive will not be fixed.

Returns

Returns TRUE if the function successfully healed the subkeys list count, FALSE otherwise.

Definition at line 829 of file cmheal.c.

{
    PAGED_CODE();
 
    /* Is self healing possible? */
    if (!CmIsSelfHealEnabled(FixHive))
    {
        DPRINT1("Self healing not possible\n");
        return FALSE;
    }
 
    /*
     * Mark the cell where we got the actual
     * cell data as dirty and fix the subkey
     * counts.
     */
    HvMarkCellDirty(Hive, CurrentCell, FALSE);
    CellData->u.KeyNode.SubKeyCounts[Stable] = Count;
 
    /* Mark the hive as in self healing mode since we repaired it */
    Hive->BaseBlock->BootType |= HBOOT_TYPE_SELF_HEAL;
    return TRUE;
}

Referenced by CmpValidateSubKeyList().

CmpRepairSubKeyList()

BOOLEAN CMAPI CmpRepairSubKeyList	(	_Inout_ PHHIVE	Hive,
		_In_ HCELL_INDEX	CurrentCell,
		_Inout_ PCELL_DATA	CellData,
		_In_ BOOLEAN	FixHive
	)

Repairs the subkey list due to corruption. The process involves by purging the whole damaged subkeys list.

Parameters

[in,out]	Hive	A pointer to a hive descriptor containing faulty data.
[in]	CurrentCell	The current cell to be marked as dirty.
[in,out]	CellData	The cell data of the current cell of which its subkeys list is to be fixed.
[in]	FixHive	If set to TRUE, self heal is triggered and the target hive will be fixed. Otherwise the hive will not be fixed.

Returns

Returns TRUE if the function successfully healed the subkeys list, FALSE otherwise.

Definition at line 883 of file cmheal.c.

{
    PAGED_CODE();
 
    /* Is self healing possible? */
    if (!CmIsSelfHealEnabled(FixHive))
    {
        DPRINT1("Self healing not possible\n");
        return FALSE;
    }
 
    /*
     * Mark the cell where we got the actual
     * cell data as dirty and fix the subkey
     * list.
     */
    HvMarkCellDirty(Hive, CurrentCell, FALSE);
    CellData->u.KeyNode.SubKeyLists[Stable] = HCELL_NIL;
    CellData->u.KeyNode.SubKeyCounts[Stable] = 0;
 
    /* Mark the hive as in self healing mode since we repaired it */
    Hive->BaseBlock->BootType |= HBOOT_TYPE_SELF_HEAL;
    return TRUE;
}

Referenced by CmpValidateKey().

CmpRepairValueList()

BOOLEAN CMAPI CmpRepairValueList	(	_Inout_ PHHIVE	Hive,
		_In_ HCELL_INDEX	CurrentCell,
		_In_ BOOLEAN	FixHive
	)

Repairs the value list due to corruption. The process involes by purging the whole damaged list.

Parameters

[in,out]	Hive	A pointer to a hive descriptor containing faulty data.
[in]	CurrentCell	The current cell to be marked as dirty.
[in]	FixHive	If set to TRUE, self heal is triggered and the target hive will be fixed. Otherwise the hive will not be fixed.

Returns

Returns TRUE if the function successfully healed the value list, FALSE otherwise.

Definition at line 765 of file cmheal.c.

{
    PCM_KEY_NODE ValueListNode;
 
    PAGED_CODE();
 
    /* Is self healing possible? */
    if (!CmIsSelfHealEnabled(FixHive))
    {
        DPRINT1("Self healing not possible\n");
        return FALSE;
    }
 
    /* Obtain a node */
    ValueListNode = (PCM_KEY_NODE)HvGetCell(Hive, CurrentCell);
    if (!ValueListNode)
    {
        DPRINT1("Could not get a node from the current cell\n");
        return FALSE;
    }
 
    /* Purge out the whole list */
    HvMarkCellDirty(Hive, CurrentCell, FALSE);
    ValueListNode->ValueList.List = HCELL_NIL;
    ValueListNode->ValueList.Count = 0;
 
    Hive->BaseBlock->BootType |= HBOOT_TYPE_SELF_HEAL;
    HvReleaseCell(Hive, CurrentCell);
    return TRUE;
}

Referenced by CmpValidateKey().

CmpRepairValueListCount()

BOOLEAN CMAPI CmpRepairValueListCount	(	_Inout_ PHHIVE	Hive,
		_In_ HCELL_INDEX	CurrentCell,
		_In_ ULONG	ListCountIndex,
		_Inout_ PCELL_DATA	ValueListData,
		_In_ BOOLEAN	FixHive
	)

Repairs the value list count of key due to corruption. The process involves by removing one damaged value less from the list.

Parameters

[in,out]	Hive	A pointer to a hive descriptor containing faulty data.
[in]	CurrentCell	The current cell to be marked as dirty.
[in]	ListCountIndex	The value count index which points to the actual value in the list to be removed.
[in,out]	ValueListData	The value list cell data containing the actual list of which the damaged is to be removed from.
[in]	FixHive	If set to TRUE, self heal is triggered and the target hive will be fixed. Otherwise the hive will not be fixed.

Returns

Returns TRUE if the function successfully healed the value list count, FALSE otherwise.

Definition at line 696 of file cmheal.c.

{
    PCM_KEY_NODE ValueListNode;
 
    PAGED_CODE();
 
    /* Is self healing possible? */
    if (!CmIsSelfHealEnabled(FixHive))
    {
        DPRINT1("Self healing not possible\n");
        return FALSE;
    }
 
    /*
     * Obtain a node from the cell that we mark it as dirty.
     * The node is that of the current cell of which its
     * value list is being validated.
     */
    ValueListNode = (PCM_KEY_NODE)HvGetCell(Hive, CurrentCell);
    if (!ValueListNode)
    {
        DPRINT1("Could not get a node from the current cell\n");
        return FALSE;
    }
 
    /*
     * Mark the current cell and value list as dirty
     * as we will be making changes onto them.
     */
    HvMarkCellDirty(Hive, CurrentCell, FALSE);
    HvMarkCellDirty(Hive, ValueListNode->ValueList.List, FALSE);
 
    /*
     * Now remove the value from the list and mark the
     * hive as in self healing mode.
     */
    CmpRemoveValueFromValueList(ValueListNode, ValueListData, ListCountIndex);
    Hive->BaseBlock->BootType |= HBOOT_TYPE_SELF_HEAL;
    HvReleaseCell(Hive, CurrentCell);
    return TRUE;
}

Referenced by CmpValidateValueListByCount().

CmpSetValueDataNew()

NTSTATUS NTAPI CmpSetValueDataNew	(	IN PHHIVE	Hive,
		IN PVOID	Data,
		IN ULONG	DataSize,
		IN HSTORAGE_TYPE	StorageType,
		IN HCELL_INDEX	ValueCell,
		OUT PHCELL_INDEX	DataCell
	)

Definition at line 289 of file cmvalue.c.

{
    PCELL_DATA CellData;
    PAGED_CODE();
    ASSERT(DataSize > CM_KEY_VALUE_SMALL);
 
    /* Check if this is a big key */
    ASSERT_VALUE_BIG(Hive, DataSize);
 
    /* Allocate a data cell */
    *DataCell = HvAllocateCell(Hive, DataSize, StorageType, HCELL_NIL);
    if (*DataCell == HCELL_NIL) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Get the actual data */
    CellData = HvGetCell(Hive, *DataCell);
    if (!CellData) ASSERT(FALSE);
 
    /* Copy our buffer into it */
    RtlCopyMemory(CellData, Data, DataSize);
 
    /* All done */
    return STATUS_SUCCESS;
}

Referenced by CmpSetValueKeyNew().

CmpValueToData()

PCELL_DATA NTAPI CmpValueToData	(	IN PHHIVE	Hive,
		IN PCM_KEY_VALUE	Value,
		OUT PULONG	Length
	)

Definition at line 167 of file cmvalue.c.

{
    PCELL_DATA Buffer;
    BOOLEAN BufferAllocated;
    HCELL_INDEX CellToRelease;
    PAGED_CODE();
 
    /* Sanity check */
    ASSERT(Hive->ReleaseCellRoutine == NULL);
 
    /* Get the actual data */
    if (!CmpGetValueData(Hive,
                         Value,
                         Length,
                         (PVOID*)&Buffer,
                         &BufferAllocated,
                         &CellToRelease))
    {
        /* We failed */
        ASSERT(BufferAllocated == FALSE);
        ASSERT(Buffer == NULL);
        return NULL;
    }
 
    /* This should never happen! */
    if (BufferAllocated)
    {
        /* Free the buffer and bugcheck */
        Hive->Free(Buffer, 0);
        KeBugCheckEx(REGISTRY_ERROR, 8, 0, (ULONG_PTR)Hive, (ULONG_PTR)Value);
    }
 
    /* Otherwise, return the cell data */
    return Buffer;
}

Referenced by BiGetRegistryValue(), CmpAddDriverToList(), CmpFindControlSet(), CmpFindTagIndex(), CmpIsLoadType(), CmpIsSafe(), CmpSortDriverList(), and RepGetValueData().

HvAllocateCell()

HCELL_INDEX CMAPI HvAllocateCell	(	PHHIVE	RegistryHive,
		ULONG	Size,
		HSTORAGE_TYPE	Storage,
		IN HCELL_INDEX	Vicinity
	)

Referenced by CmCreateRootNode(), CmiAddValueKey(), CmiCreateSecurityKey(), CmiCreateSubKey(), CmpAddSubKey(), CmpAddValueToList(), CmpCopyCell(), CmpCreateLinkNode(), CmpCreateRootNode(), CmpDoCreateChild(), CmpSetValueDataNew(), CmpSetValueKeyExisting(), CmpSetValueKeyNew(), CmpSplitLeaf(), and RegSetValueExW().

HvFree()

VOID CMAPI HvFree

(

PHHIVE

RegistryHive

)

Referenced by CmiInitializeHive(), CmpDestroyHive(), and CmUnloadKey().

HvFreeCell()

VOID CMAPI HvFreeCell	(	PHHIVE	RegistryHive,
		HCELL_INDEX	CellOffset
	)

Definition at line 468 of file hivecell.c.

{
    PHCELL Free;
    PHCELL Neighbor;
    PHBIN Bin;
    ULONG CellType;
    ULONG CellBlock;
 
    ASSERT(RegistryHive->ReadOnly == FALSE);
 
    CMLTRACE(CMLIB_HCELL_DEBUG, "%s - Hive %p, CellIndex %08lx\n",
             __FUNCTION__, RegistryHive, CellIndex);
 
    Free = HvpGetCellHeader(RegistryHive, CellIndex);
 
    ASSERT(Free->Size < 0);
 
    Free->Size = -Free->Size;
 
    CellType = HvGetCellType(CellIndex);
    CellBlock = HvGetCellBlock(CellIndex);
 
    /* FIXME: Merge free blocks */
    Bin = (PHBIN)RegistryHive->Storage[CellType].BlockList[CellBlock].BinAddress;
 
    if ((CellIndex & ~HCELL_TYPE_MASK) + Free->Size <
        Bin->FileOffset + Bin->Size)
    {
        Neighbor = (PHCELL)((ULONG_PTR)Free + Free->Size);
        if (Neighbor->Size > 0)
        {
            HvpRemoveFree(RegistryHive, Neighbor,
                          ((HCELL_INDEX)((ULONG_PTR)Neighbor - (ULONG_PTR)Bin +
                            Bin->FileOffset)) | (CellIndex & HCELL_TYPE_MASK));
            Free->Size += Neighbor->Size;
        }
    }
 
    Neighbor = (PHCELL)(Bin + 1);
    while (Neighbor < Free)
    {
        if (Neighbor->Size > 0)
        {
            if ((ULONG_PTR)Neighbor + Neighbor->Size == (ULONG_PTR)Free)
            {
                HCELL_INDEX NeighborCellIndex =
                    ((HCELL_INDEX)((ULONG_PTR)Neighbor - (ULONG_PTR)Bin +
                     Bin->FileOffset)) | (CellIndex & HCELL_TYPE_MASK);
 
                if (HvpComputeFreeListIndex(Neighbor->Size) !=
                    HvpComputeFreeListIndex(Neighbor->Size + Free->Size))
                {
                   HvpRemoveFree(RegistryHive, Neighbor, NeighborCellIndex);
                   Neighbor->Size += Free->Size;
                   HvpAddFree(RegistryHive, Neighbor, NeighborCellIndex);
                }
                else
                    Neighbor->Size += Free->Size;
 
                if (CellType == Stable)
                    HvMarkCellDirty(RegistryHive, NeighborCellIndex, FALSE);
 
                return;
            }
            Neighbor = (PHCELL)((ULONG_PTR)Neighbor + Neighbor->Size);
        }
        else
        {
            Neighbor = (PHCELL)((ULONG_PTR)Neighbor - Neighbor->Size);
        }
    }
 
    /* Add block to the list of free blocks */
    HvpAddFree(RegistryHive, Free, CellIndex);
 
    if (CellType == Stable)
        HvMarkCellDirty(RegistryHive, CellIndex, FALSE);
}

Referenced by CmCreateRootNode(), CmiAddValueKey(), CmiCreateSubKey(), CmpCopyKeyValueList(), CmpCopyValue(), CmpDeepCopyKeyInternal(), CmpDoCreateChild(), CmpFreeKeyBody(), CmpFreeKeyByCell(), CmpFreeSecurityDescriptor(), CmpFreeValue(), CmpFreeValueData(), CmpRemoveSubKey(), CmpRemoveValueFromList(), CmpSetValueKeyNew(), CmpSplitLeaf(), HvReallocateCell(), and RegSetValueExW().

HvGetCellSize()

LONG CMAPI HvGetCellSize	(	PHHIVE	RegistryHive,
		PVOID	Cell
	)

Referenced by CmpAddToLeaf(), CmpCopyCell(), CmpSetValueKeyExisting(), CmpSplitLeaf(), CmpValidateKey(), CmpValidateValueList(), CmpValidateValueListByCount(), and RegSetValueExW().

HvHiveWillShrink()

BOOLEAN CMAPI HvHiveWillShrink

(

IN PHHIVE

RegistryHive

)

Referenced by CmFlushKey(), and CmpDoFlushAll().

HvInitialize()

NTSTATUS CMAPI HvInitialize	(	PHHIVE	RegistryHive,
		ULONG	OperationType,
		ULONG	HiveFlags,
		ULONG	FileType,
		PVOID HiveData	OPTIONAL,
		PALLOCATE_ROUTINE	Allocate,
		PFREE_ROUTINE	Free,
		PFILE_SET_SIZE_ROUTINE	FileSetSize,
		PFILE_WRITE_ROUTINE	FileWrite,
		PFILE_READ_ROUTINE	FileRead,
		PFILE_FLUSH_ROUTINE	FileFlush,
		ULONG Cluster	OPTIONAL,
		PCUNICODE_STRING FileName	OPTIONAL
	)

Referenced by BiInitializeAndValidateHive(), CmGetSystemControlValues(), CmiInitializeHive(), CmpInitializeHive(), and RegInitializeHive().

HvIsCellAllocated()

BOOLEAN CMAPI HvIsCellAllocated	(	IN PHHIVE	RegistryHive,
		IN HCELL_INDEX	CellIndex
	)

Definition at line 53 of file hivecell.c.

{
    ULONG Type, Block;
 
    /* If it's a flat hive, the cell is always allocated */
    if (RegistryHive->Flat)
        return TRUE;
 
    /* Otherwise, get the type and make sure it's valid */
    Type = HvGetCellType(CellIndex);
    Block = HvGetCellBlock(CellIndex);
    if (Block >= RegistryHive->Storage[Type].Length)
        return FALSE;
 
    /* Try to get the cell block */
    if (RegistryHive->Storage[Type].BlockList[Block].BlockAddress)
        return TRUE;
 
    /* No valid block, fail */
    return FALSE;
}

Referenced by CmpValidateClass(), CmpValidateKey(), CmpValidateSubKeyList(), CmpValidateValueList(), and CmpValidateValueListByCount().

HvIsCellDirty()

BOOLEAN CMAPI HvIsCellDirty	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell
	)

Definition at line 153 of file hivecell.c.

{
    BOOLEAN IsDirty = FALSE;
 
    /* Sanity checks */
    ASSERT(Hive->ReadOnly == FALSE);
 
    /* Volatile cells are always "dirty" */
    if (HvGetCellType(Cell) == Volatile)
        return TRUE;
 
    /* Check if the dirty bit is set */
    if (RtlCheckBit(&Hive->DirtyVector, Cell / HBLOCK_SIZE))
        IsDirty = TRUE;
 
    /* Return result as boolean*/
    return IsDirty;
}

Referenced by CmDeleteKey(), CmDeleteValueKey(), CmpAddValueToList(), CmpRemoveSubKey(), CmpRemoveValueFromList(), CmpSetValueKeyExisting(), CmpSetValueKeyNew(), RegDeleteKeyW(), and RegDeleteValueW().

HvMarkCellDirty()

BOOLEAN CMAPI HvMarkCellDirty	(	PHHIVE	RegistryHive,
		HCELL_INDEX	CellOffset,
		BOOLEAN	HoldingLock
	)

Definition at line 109 of file hivecell.c.

{
    ULONG CellBlock;
    ULONG CellLastBlock;
 
    ASSERT(RegistryHive->ReadOnly == FALSE);
 
    CMLTRACE(CMLIB_HCELL_DEBUG, "%s - Hive %p, CellIndex %08lx, HoldingLock %u\n",
             __FUNCTION__, RegistryHive, CellIndex, HoldingLock);
 
    if (HvGetCellType(CellIndex) != Stable)
        return TRUE;
 
    CellBlock     = HvGetCellBlock(CellIndex);
    CellLastBlock = HvGetCellBlock(CellIndex + HBLOCK_SIZE - 1);
 
    RtlSetBits(&RegistryHive->DirtyVector,
               CellBlock, CellLastBlock - CellBlock);
    RegistryHive->DirtyCount++;
 
    /*
     * FIXME: Querying a lazy flush operation is needed to
     * ensure that the dirty data is being flushed to disk
     * accordingly. However, this operation has to be done
     * in a helper like HvMarkDirty that marks specific parts
     * of the hive as dirty. Since we do not have such kind
     * of helper we have to perform an eventual lazy flush
     * when marking cells as dirty here for the moment being,
     * so that not only we flush dirty data but also write
     * logs.
     */
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
    if (!(RegistryHive->HiveFlags & HIVE_NOLAZYFLUSH))
    {
        CmpLazyFlush();
    }
#endif
    return TRUE;
}

Referenced by CmDeleteValueKey(), CmiAddSubKey(), CmiAddValueKey(), CmpAddSubKey(), CmpAddToLeaf(), CmpCreateLinkNode(), CmpDoCreate(), CmpMarkIndexDirty(), CmpMarkKeyDirty(), CmpMarkValueDataDirty(), CmpPurgeVolatiles(), CmpRemoveSubKeyInLeaf(), CmpRemoveSubkeyInRoot(), CmpRepairClassOfNodeKey(), CmpRepairKeyNodeSignature(), CmpRepairParentKey(), CmpRepairParentNode(), CmpRepairSubKeyCounts(), CmpRepairSubKeyList(), CmpRepairValueList(), CmpRepairValueListCount(), CmpSelectLeaf(), CmpSetValueKeyExisting(), CmpSetValueKeyNew(), CmpSplitLeaf(), CmpValidateClass(), CmSetValueKey(), HvAllocateCell(), HvFreeCell(), RegDeleteValueW(), and RegSetValueExW().

HvpAddBin()

PHBIN CMAPI HvpAddBin	(	PHHIVE	RegistryHive,
		ULONG	Size,
		HSTORAGE_TYPE	Storage
	)

Definition at line 12 of file hivebin.c.

{
    PHMAP_ENTRY BlockList;
    PHBIN Bin;
    ULONG BinSize;
    ULONG i;
    ULONG BitmapSize;
    ULONG BlockCount;
    ULONG OldBlockListSize;
    PHCELL Block;
 
    BinSize = ROUND_UP(Size + sizeof(HBIN), HBLOCK_SIZE);
    BlockCount = BinSize / HBLOCK_SIZE;
 
    Bin = RegistryHive->Allocate(BinSize, TRUE, TAG_CM);
    if (Bin == NULL)
        return NULL;
    RtlZeroMemory(Bin, BinSize);
 
    Bin->Signature = HV_HBIN_SIGNATURE;
    Bin->FileOffset = RegistryHive->Storage[Storage].Length *
                      HBLOCK_SIZE;
    Bin->Size = BinSize;
 
    /* Allocate new block list */
    OldBlockListSize = RegistryHive->Storage[Storage].Length;
    BlockList = RegistryHive->Allocate(sizeof(HMAP_ENTRY) *
                                       (OldBlockListSize + BlockCount),
                                       TRUE,
                                       TAG_CM);
    if (BlockList == NULL)
    {
        RegistryHive->Free(Bin, 0);
        return NULL;
    }
 
    if (OldBlockListSize > 0)
    {
        RtlCopyMemory(BlockList, RegistryHive->Storage[Storage].BlockList,
                      OldBlockListSize * sizeof(HMAP_ENTRY));
        RegistryHive->Free(RegistryHive->Storage[Storage].BlockList, 0);
    }
 
    RegistryHive->Storage[Storage].BlockList = BlockList;
    RegistryHive->Storage[Storage].Length += BlockCount;
 
    for (i = 0; i < BlockCount; i++)
    {
        RegistryHive->Storage[Storage].BlockList[OldBlockListSize + i].BlockAddress =
            ((ULONG_PTR)Bin + (i * HBLOCK_SIZE));
        RegistryHive->Storage[Storage].BlockList[OldBlockListSize + i].BinAddress = (ULONG_PTR)Bin;
    }
 
    /* Initialize a free block in this heap. */
    Block = (PHCELL)(Bin + 1);
    Block->Size = (LONG)(BinSize - sizeof(HBIN));
 
    if (Storage == Stable)
    {
        /* Calculate bitmap size in bytes (always a multiple of 32 bits). */
        BitmapSize = ROUND_UP(RegistryHive->Storage[Stable].Length,
                              sizeof(ULONG) * 8) / 8;
 
        /* Grow bitmap if necessary. */
        if (BitmapSize > RegistryHive->DirtyVector.SizeOfBitMap / 8)
        {
            PULONG BitmapBuffer;
 
            BitmapBuffer = RegistryHive->Allocate(BitmapSize, TRUE, TAG_CM);
            RtlZeroMemory(BitmapBuffer, BitmapSize);
            if (RegistryHive->DirtyVector.SizeOfBitMap > 0)
            {
                ASSERT(RegistryHive->DirtyVector.Buffer);
                RtlCopyMemory(BitmapBuffer,
                              RegistryHive->DirtyVector.Buffer,
                              RegistryHive->DirtyVector.SizeOfBitMap / 8);
                RegistryHive->Free(RegistryHive->DirtyVector.Buffer, 0);
            }
            RtlInitializeBitMap(&RegistryHive->DirtyVector, BitmapBuffer,
                                BitmapSize * 8);
        }
 
        /* Mark new bin dirty. */
        RtlSetBits(&RegistryHive->DirtyVector,
                   Bin->FileOffset / HBLOCK_SIZE,
                   BlockCount);
 
        /* Update size in the base block */
        RegistryHive->BaseBlock->Length += BinSize;
    }
 
    return Bin;
}

Referenced by HvAllocateCell().

HvpCreateHiveFreeCellList()

NTSTATUS CMAPI HvpCreateHiveFreeCellList

(

PHHIVE

Hive

)

Definition at line 306 of file hivecell.c.

{
    HCELL_INDEX BlockOffset;
    PHCELL FreeBlock;
    ULONG BlockIndex;
    ULONG FreeOffset;
    PHBIN Bin;
    NTSTATUS Status;
    ULONG Index;
 
    /* Initialize the free cell list */
    for (Index = 0; Index < 24; Index++)
    {
        Hive->Storage[Stable].FreeDisplay[Index] = HCELL_NIL;
        Hive->Storage[Volatile].FreeDisplay[Index] = HCELL_NIL;
    }
 
    BlockOffset = 0;
    BlockIndex = 0;
    while (BlockIndex < Hive->Storage[Stable].Length)
    {
        Bin = (PHBIN)Hive->Storage[Stable].BlockList[BlockIndex].BinAddress;
 
        /* Search free blocks and add to list */
        FreeOffset = sizeof(HBIN);
        while (FreeOffset < Bin->Size)
        {
            FreeBlock = (PHCELL)((ULONG_PTR)Bin + FreeOffset);
            if (FreeBlock->Size > 0)
            {
                Status = HvpAddFree(Hive, FreeBlock, Bin->FileOffset + FreeOffset);
                if (!NT_SUCCESS(Status))
                    return Status;
 
                FreeOffset += FreeBlock->Size;
            }
            else
            {
                FreeOffset -= FreeBlock->Size;
            }
        }
 
        BlockIndex += Bin->Size / HBLOCK_SIZE;
        BlockOffset += Bin->Size;
    }
 
    return STATUS_SUCCESS;
}

Referenced by HvpInitializeMemoryHive().

HvpGetCellData()

PCELL_DATA CMAPI HvpGetCellData	(	_In_ PHHIVE	Hive,
		_In_ HCELL_INDEX	CellIndex
	)

Definition at line 77 of file hivecell.c.

{
    return (PCELL_DATA)(HvpGetCellHeader(Hive, CellIndex) + 1);
}

Referenced by HvInitialize().

HvpHiveHeaderChecksum()

ULONG CMAPI HvpHiveHeaderChecksum

(

PHBASE_BLOCK

HiveHeader

)

Definition at line 17 of file hivesum.c.

{
    PULONG Buffer = (PULONG)HiveHeader;
    ULONG Sum = 0;
    ULONG i;
 
    for (i = 0; i < 127; i++)
        Sum ^= Buffer[i];
    if (Sum == (ULONG)-1)
        Sum = (ULONG)-2;
    if (Sum == 0)
        Sum = 1;
 
    return Sum;
}

Referenced by CmCreateRootNode(), HvIsInPlaceBaseBlockValid(), HvpRecoverHeaderFromLog(), HvpVerifyHiveHeader(), HvpWriteHive(), HvpWriteLog(), and RegRecoverDataHive().

HvpVerifyHiveHeader()

BOOLEAN CMAPI HvpVerifyHiveHeader	(	_In_ PHBASE_BLOCK	BaseBlock,
		_In_ ULONG	FileType
	)

Validates the base block header of a registry file (hive or log).

Parameters

[in]	BaseBlock	A pointer to a base block header to be validated.
[in]	FileType	The file type of a registry file to check against the file type of the base block.

Returns

Returns TRUE if the base block header is valid, FALSE otherwise.

Definition at line 49 of file hiveinit.c.

{
    if (BaseBlock->Signature != HV_HBLOCK_SIGNATURE ||
        BaseBlock->Major != HSYS_MAJOR ||
        BaseBlock->Minor < HSYS_MINOR ||
        BaseBlock->Type != FileType ||
        BaseBlock->Format != HBASE_FORMAT_MEMORY ||
        BaseBlock->Cluster != 1 ||
        BaseBlock->Sequence1 != BaseBlock->Sequence2 ||
        HvpHiveHeaderChecksum(BaseBlock) != BaseBlock->CheckSum)
    {
        DPRINT1("Verify Hive Header failed:\n");
        DPRINT1("    Signature: 0x%x, expected 0x%x; Major: 0x%x, expected 0x%x\n",
                BaseBlock->Signature, HV_HBLOCK_SIGNATURE, BaseBlock->Major, HSYS_MAJOR);
        DPRINT1("    Minor: 0x%x expected to be >= 0x%x; Type: 0x%x, expected 0x%x\n",
                BaseBlock->Minor, HSYS_MINOR, BaseBlock->Type, FileType);
        DPRINT1("    Format: 0x%x, expected 0x%x; Cluster: 0x%x, expected 1\n",
                BaseBlock->Format, HBASE_FORMAT_MEMORY, BaseBlock->Cluster);
        DPRINT1("    Sequence: 0x%x, expected 0x%x; Checksum: 0x%x, expected 0x%x\n",
                BaseBlock->Sequence1, BaseBlock->Sequence2,
                HvpHiveHeaderChecksum(BaseBlock), BaseBlock->CheckSum);
 
        return FALSE;
    }
 
    return TRUE;
}

Referenced by HvpGetHiveHeader(), HvpInitializeFlatHive(), HvpInitializeMemoryHive(), HvpRecoverHeaderFromLog(), and RegRecoverHeaderHive().

HvReallocateCell()

HCELL_INDEX CMAPI HvReallocateCell	(	PHHIVE	RegistryHive,
		HCELL_INDEX	CellOffset,
		ULONG	Size
	)

Definition at line 421 of file hivecell.c.

{
    PVOID OldCell;
    PVOID NewCell;
    LONG OldCellSize;
    HCELL_INDEX NewCellIndex;
    HSTORAGE_TYPE Storage;
 
    ASSERT(CellIndex != HCELL_NIL);
 
    CMLTRACE(CMLIB_HCELL_DEBUG, "%s - Hive %p, CellIndex %08lx, Size %x\n",
             __FUNCTION__, RegistryHive, CellIndex, Size);
 
    Storage = HvGetCellType(CellIndex);
 
    OldCell = HvGetCell(RegistryHive, CellIndex);
    OldCellSize = HvGetCellSize(RegistryHive, OldCell);
    ASSERT(OldCellSize > 0);
 
    /*
     * If new data size is larger than the current, destroy current
     * data block and allocate a new one.
     *
     * FIXME: Merge with adjacent free cell if possible.
     * FIXME: Implement shrinking.
     */
    if (Size > (ULONG)OldCellSize)
    {
        NewCellIndex = HvAllocateCell(RegistryHive, Size, Storage, HCELL_NIL);
        if (NewCellIndex == HCELL_NIL)
            return HCELL_NIL;
 
        NewCell = HvGetCell(RegistryHive, NewCellIndex);
        RtlCopyMemory(NewCell, OldCell, (SIZE_T)OldCellSize);
 
        HvFreeCell(RegistryHive, CellIndex);
 
        return NewCellIndex;
    }
 
    return CellIndex;
}

Referenced by CmpAddToLeaf(), CmpAddValueToList(), CmpRemoveValueFromList(), CmpSetValueKeyExisting(), and CmpSplitLeaf().

HvReleaseFreeCellRefArray()

VOID CMAPI HvReleaseFreeCellRefArray

(

IN OUT PHV_TRACK_CELL_REF

CellRef

)

Definition at line 634 of file hivecell.c.

{
    ULONG i;
 
    PAGED_CODE();
 
    ASSERT(CellRef);
 
    /* Any references in the static array? */
    if (CellRef->StaticCount > 0)
    {
        /* Sanity check */
        ASSERT(CellRef->StaticCount <= STATIC_CELL_PAIR_COUNT);
 
        /* Loop over them and release them */
        for (i = 0; i < CellRef->StaticCount; i++)
        {
            HvReleaseCell(CellRef->StaticArray[i].Hive,
                          CellRef->StaticArray[i].Cell);
        }
 
        /* We can reuse the static array */
        CellRef->StaticCount = 0;
    }
 
    /* Any references in the dynamic array? */
    if (CellRef->Count > 0)
    {
        /* Sanity checks */
        ASSERT(CellRef->Count <= CellRef->Max);
        ASSERT(CellRef->CellArray);
 
        /* Loop over them and release them */
        for (i = 0; i < CellRef->Count; i++)
        {
            HvReleaseCell(CellRef->CellArray[i].Hive,
                          CellRef->CellArray[i].Cell);
        }
 
        /* We can reuse the dynamic array */
        CmpFree(CellRef->CellArray, 0); // TAG_CM
        CellRef->CellArray = NULL;
        CellRef->Count = CellRef->Max = 0;
    }
}

Referenced by CmEnumerateKey(), and CmQueryKey().

HvSyncHive()

BOOLEAN CMAPI HvSyncHive

(

PHHIVE

RegistryHive

)

Referenced by _Function_class_(), CmFlushKey(), CmLoadKey(), CmpDoFlushAll(), and CmpDoFlushNextHive().

HvSyncHiveFromRecover()

BOOLEAN CMAPI HvSyncHiveFromRecover

(

_In_ PHHIVE

RegistryHive

)

Synchronizes a hive with recovered data during a healing/resuscitation operation of the registry.

Parameters

[in]

RegistryHive

A pointer to a hive descriptor where data syncing is to be done.

Returns

Returns TRUE if hive syncing during recovery succeeded, FALSE otherwise.

Definition at line 672 of file hivewrt.c.

{
    ASSERT(!RegistryHive->ReadOnly);
    ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE);
 
    /* Call the private API call to do the deed for us */
    return HvpWriteHive(RegistryHive, TRUE, HFILE_TYPE_PRIMARY);
}

Referenced by HvInitialize().

HvTrackCellRef()

BOOLEAN CMAPI HvTrackCellRef	(	IN OUT PHV_TRACK_CELL_REF	CellRef,
		IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell
	)

Definition at line 554 of file hivecell.c.

{
    PHV_HIVE_CELL_PAIR NewCellArray;
 
    PAGED_CODE();
 
    /* Sanity checks */
    ASSERT(CellRef);
    ASSERT(Hive);
    ASSERT(Cell != HCELL_NIL);
 
    /* NOTE: The hive cell is already referenced! */
 
    /* Less than 4? Use the static array */
    if (CellRef->StaticCount < STATIC_CELL_PAIR_COUNT)
    {
        /* Add the reference */
        CellRef->StaticArray[CellRef->StaticCount].Hive = Hive;
        CellRef->StaticArray[CellRef->StaticCount].Cell = Cell;
        CellRef->StaticCount++;
        return TRUE;
    }
 
    DPRINT("HvTrackCellRef: Static array full, use dynamic array.\n");
 
    /* Sanity checks */
    if (CellRef->Max == 0)
    {
        /* The dynamic array must not have been allocated already */
        ASSERT(CellRef->CellArray == NULL);
        ASSERT(CellRef->Count == 0);
    }
    else
    {
        /* The dynamic array must be allocated */
        ASSERT(CellRef->CellArray);
    }
    ASSERT(CellRef->Count <= CellRef->Max);
 
    if (CellRef->Count == CellRef->Max)
    {
        /* Allocate a new reference table */
        NewCellArray = CmpAllocate((CellRef->Max + CELL_REF_INCREMENT) * sizeof(HV_HIVE_CELL_PAIR),
                                   TRUE,
                                   TAG_CM);
        if (!NewCellArray)
        {
            DPRINT1("HvTrackCellRef: Cannot reallocate the reference table.\n");
            /* We failed, dereference the hive cell */
            HvReleaseCell(Hive, Cell);
            return FALSE;
        }
 
        /* Free the old reference table and use the new one */
        if (CellRef->CellArray)
        {
            /* Copy the handles from the old table to the new one */
            RtlCopyMemory(NewCellArray,
                          CellRef->CellArray,
                          CellRef->Max * sizeof(HV_HIVE_CELL_PAIR));
            CmpFree(CellRef->CellArray, 0); // TAG_CM
        }
        CellRef->CellArray = NewCellArray;
        CellRef->Max += CELL_REF_INCREMENT;
    }
 
    // ASSERT(CellRef->Count < CellRef->Max);
 
    /* Add the reference */
    CellRef->CellArray[CellRef->Count].Hive = Hive;
    CellRef->CellArray[CellRef->Count].Cell = Cell;
    CellRef->Count++;
    return TRUE;
}

Referenced by CmEnumerateKey(), and CmQueryKey().

HvValidateBin()

CM_CHECK_REGISTRY_STATUS NTAPI HvValidateBin	(	_In_ PHHIVE	Hive,
		_In_ PHBIN	Bin
	)

Validates a bin from a hive. It performs checks against the cells from this bin, ensuring the bin is not corrupt and that the cells are consistent with each other.

Parameters

[in]	Hive	A pointer to a hive descriptor of which a hive bin is to be validated.
[in]	Bin	A pointer to a bin where its cells are to be validated.

Returns

CM_CHECK_REGISTRY_GOOD is returned if the bin is valid and not corrupt. CM_CHECK_REGISTRY_BIN_SIGNATURE_HEADER_CORRUPT is returned if this bin has a corrupt signature. CM_CHECK_REGISTRY_BAD_FREE_CELL is returned if the free cell has a bogus size. CM_CHECK_REGISTRY_BAD_ALLOC_CELL is returned for the allocated cell has a bogus size.

Definition at line 1413 of file cmcheck.c.

{
    PHCELL Cell, Basket;
 
    PAGED_CODE();
 
    ASSERT(Bin);
    ASSERT(Hive);
 
    /* Ensure that this bin we got has valid signature header */
    if (Bin->Signature != HV_HBIN_SIGNATURE)
    {
        DPRINT1("The bin's signature header is corrupt\n");
        return CM_CHECK_REGISTRY_BIN_SIGNATURE_HEADER_CORRUPT;
    }
 
    /*
     * Walk over all the cells from this bin and
     * validate that they're consistent with the bin.
     * Namely we want that each cell from this bin doesn't
     * have a bogus size.
     */
    Basket = (PHCELL)((PUCHAR)Bin + Bin->Size);
    for (Cell = GET_CELL_BIN(Bin);
         Cell < Basket;
         Cell = (PHCELL)((PUCHAR)Cell + abs(Cell->Size)))
    {
        if (IsFreeCell(Cell))
        {
            /*
             * This cell is free, check that
             * the size of this cell is not bogus.
             */
            if (Cell->Size > Bin->Size ||
                Cell->Size == 0)
            {
                /*
                 * This cell has too much free space that
                 * exceeds the boundary of the bin size.
                 * Otherwise the cell doesn't have actual
                 * free space (aka Size == 0) which is a
                 * no go for a bin.
                 */
                DPRINT1("The free cell exceeds the bin size or cell size equal to 0 (cell 0x%p, cell size %d, bin size %lu)\n",
                        Cell, Cell->Size, Bin->Size);
                return CM_CHECK_REGISTRY_BAD_FREE_CELL;
            }
        }
        else
        {
            /*
             * This cell is allocated, make sure that
             * the size of this cell is not bogus.
             */
            if (abs(Cell->Size) > Bin->Size)
            {
                /*
                 * This cell allocated too much space
                 * that exceeds the boundary of the
                 * bin size.
                 */
                DPRINT1("The allocated cell exceeds the bin size (cell 0x%p, cell size %d, bin size %lu)\n",
                        Cell, abs(Cell->Size), Bin->Size);
                return CM_CHECK_REGISTRY_BAD_ALLOC_CELL;
            }
        }
    }
 
    return CM_CHECK_REGISTRY_GOOD;
}

Referenced by HvValidateHive().

HvValidateHive()

CM_CHECK_REGISTRY_STATUS NTAPI HvValidateHive

(

_In_ PHHIVE

Hive

)

Validates a registry hive. This function ensures that the storage of this hive has valid bins.

Parameters

[in]

Hive

A pointer to a hive descriptor where validation on its hive bins is to be performed.

Returns

CM_CHECK_REGISTRY_GOOD is returned if the hive is valid. CM_CHECK_REGISTRY_HIVE_CORRUPT_SIGNATURE is returned if the hive has a corrupted signature. CM_CHECK_REGISTRY_BIN_SIZE_OR_OFFSET_CORRUPT is returned if the captured bin has a bad size. A failure CM status code is returned otherwise.

Definition at line 1505 of file cmcheck.c.

{
    CM_CHECK_REGISTRY_STATUS CmStatusCode;
    ULONG StorageIndex;
    ULONG BlockIndex;
    ULONG StorageLength;
    PHBIN Bin;
 
    PAGED_CODE();
 
    ASSERT(Hive);
 
    /* Is the hive signature valid? */
    if (Hive->Signature != HV_HHIVE_SIGNATURE)
    {
        DPRINT1("Hive's signature corrupted (signature %lu)\n", Hive->Signature);
        return CM_CHECK_REGISTRY_HIVE_CORRUPT_SIGNATURE;
    }
 
    /*
     * Now loop each bin in the storage of this
     * hive.
     */
    for (StorageIndex = 0; StorageIndex < Hive->StorageTypeCount; StorageIndex++)
    {
        /* Get the storage length at this index */
        StorageLength = Hive->Storage[StorageIndex].Length;
 
        for (BlockIndex = 0; BlockIndex < StorageLength;)
        {
            /* Go to the next if this bin does not exist */
            if (Hive->Storage[StorageIndex].BlockList[BlockIndex].BinAddress == (ULONG_PTR)NULL)
            {
                continue;
            }
 
            /*
             * Capture this bin and ensure that such
             * bin is within the offset and the size
             * is not bogus.
             */
            Bin = GET_HHIVE_BIN(Hive, StorageIndex, BlockIndex);
            if (Bin->Size > (StorageLength * HBLOCK_SIZE) ||
                (Bin->FileOffset / HBLOCK_SIZE) != BlockIndex)
            {
                DPRINT1("Bin size or offset is corrupt (bin size %lu, file offset %lu, storage length %lu)\n",
                        Bin->Size, Bin->FileOffset, StorageLength);
                return CM_CHECK_REGISTRY_BIN_SIZE_OR_OFFSET_CORRUPT;
            }
 
            /* Validate the rest of the bin */
            CmStatusCode = HvValidateBin(Hive, Bin);
            if (!CM_CHECK_REGISTRY_SUCCESS(CmStatusCode))
            {
                DPRINT1("This bin is not valid (bin 0x%p)\n", Bin);
                return CmStatusCode;
            }
 
            /* Go to the next block */
            BlockIndex += Bin->Size / HBLOCK_SIZE;
        }
    }
 
    return CM_CHECK_REGISTRY_GOOD;
}

Referenced by CmCheckRegistry().

HvWriteAlternateHive()

BOOLEAN CMAPI HvWriteAlternateHive

(

_In_ PHHIVE

RegistryHive

)

Writes data to an alternate registry hive. An alternate hive is usually backed up by a primary hive. This function is tipically used to force write data into the alternate hive if both hives no longer match.

Parameters

[in]

RegistryHive

A pointer to a hive descriptor where data is to be written into.

Returns

Returns TRUE if hive writing has succeeded, FALSE otherwise.

Definition at line 634 of file hivewrt.c.

{
    ASSERT(!RegistryHive->ReadOnly);
    ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE);
    ASSERT(RegistryHive->Alternate);
 
#if !defined(_BLDR_)
    /* Update hive header modification time */
    KeQuerySystemTime(&RegistryHive->BaseBlock->TimeStamp);
#endif
 
    /* Update hive file */
    if (!HvpWriteHive(RegistryHive, FALSE, HFILE_TYPE_ALTERNATE))
    {
        DPRINT1("Failed to write the alternate hive\n");
        return FALSE;
    }
 
    return TRUE;
}

Referenced by _Function_class_().

HvWriteHive()

BOOLEAN CMAPI HvWriteHive

(

PHHIVE

RegistryHive

)

Referenced by CmSaveKey(), CmSaveMergedKeys(), and ExportBinaryHive().

Variable Documentation

CmlibTraceLevel

ULONG CmlibTraceLevel

extern

Definition at line 12 of file cminit.c.