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	CMAPI   NTAPI
#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 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	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	CmCreateRootNode (PHHIVE Hive, PCWSTR Name)
VOID CMAPI	CmPrepareHive (PHHIVE RegistryHive)
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 14 of file cmlib.h.

_WINBASE_

#define _WINBASE_

Definition at line 178 of file cmlib.h.

_WINDEF_

#define _WINDEF_

Definition at line 177 of file cmlib.h.

_WINNLS_

#define _WINNLS_

Definition at line 179 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 311 of file cmlib.h.

CMAPI

#define CMAPI   NTAPI

Definition at line 210 of file cmlib.h.

CMLIB_HCELL_DEBUG

#define CMLIB_HCELL_DEBUG   0x01

Definition at line 186 of file cmlib.h.

CMLTRACE

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

Definition at line 165 of file cmlib.h.

CMP_SECURITY_HASH_LISTS

#define CMP_SECURITY_HASH_LISTS   64

Definition at line 223 of file cmlib.h.

HvGetCell

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

Definition at line 381 of file cmlib.h.

HvReleaseCell

#define HvReleaseCell	(		Hive,
			Cell
	)

Value:

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

Definition at line 384 of file cmlib.h.

ROUND_DOWN

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

Definition at line 190 of file cmlib.h.

ROUND_UP

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

Definition at line 189 of file cmlib.h.

STATIC_CELL_PAIR_COUNT

#define STATIC_CELL_PAIR_COUNT   4

Definition at line 296 of file cmlib.h.

TAG_CM

#define TAG_CM   ' MC'

Definition at line 205 of file cmlib.h.

TAG_CMHIVE

#define TAG_CMHIVE   'vHMC'

Definition at line 207 of file cmlib.h.

TAG_CMSD

#define TAG_CMSD   'DSMC'

Definition at line 208 of file cmlib.h.

TAG_KCB

#define TAG_KCB   'bkMC'

Definition at line 206 of file cmlib.h.

Typedef Documentation

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 220 of file cmlib.h.

PCM_KEY_CONTROL_BLOCK

typedef struct _CM_KEY_CONTROL_BLOCK* PCM_KEY_CONTROL_BLOCK

Definition at line 219 of file cmlib.h.

PCM_KEY_SECURITY_CACHE_ENTRY

typedef struct _CM_KEY_SECURITY_CACHE_ENTRY* PCM_KEY_SECURITY_CACHE_ENTRY

Definition at line 218 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

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().

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 46 of file registry.c.

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

Referenced by CmiInitializeHive(), and RegImportBinaryHive().

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 CmpDoCompareKeyName(), CmpFindNameInList(), CmpFindValueByNameFromCache(), and CmpGetNameControlBlock().

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(), and CmpFindDrivers().

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 57 of file registry.c.

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

Referenced by CmiInitializeHive(), and RegImportBinaryHive().

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(), 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 340 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 319 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(), and CmpSetValueKeyExisting().

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().

CmPrepareHive()

VOID CMAPI CmPrepareHive

(

PHHIVE

RegistryHive

)

Definition at line 135 of file cminit.c.

{
    PCM_KEY_NODE RootCell;
 
    RootCell = (PCM_KEY_NODE)HvGetCell(RegistryHive, RegistryHive->BaseBlock->RootCell);
    CmpPrepareKey(RegistryHive, RootCell);
}

Referenced by BiInitializeAndValidateHive(), and HvInitialize().

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

)

Definition at line 628 of file hiveinit.c.

{
    if (!RegistryHive->ReadOnly)
    {
        /* Release hive bitmap */
        if (RegistryHive->DirtyVector.Buffer)
        {
            RegistryHive->Free(RegistryHive->DirtyVector.Buffer, 0);
        }
 
        HvpFreeHiveBins(RegistryHive);
 
        /* Free the BaseBlock */
        if (RegistryHive->BaseBlock)
        {
            RegistryHive->Free(RegistryHive->BaseBlock, RegistryHive->BaseBlockAlloc);
            RegistryHive->BaseBlock = NULL;
        }
    }
}

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(), and RegSetValueExW().

HvHiveWillShrink()

BOOLEAN CMAPI HvHiveWillShrink

(

IN PHHIVE

RegistryHive

)

Definition at line 277 of file hivewrt.c.

{
    /* No shrinking yet */
    UNIMPLEMENTED_ONCE;
    return FALSE;
}

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
	)

Definition at line 522 of file hiveinit.c.

{
    NTSTATUS Status;
    PHHIVE Hive = RegistryHive;
 
    /*
     * Create a new hive structure that will hold all the maintenance data.
     */
 
    RtlZeroMemory(Hive, sizeof(HHIVE));
    Hive->Signature = HV_HHIVE_SIGNATURE;
 
    Hive->Allocate = Allocate;
    Hive->Free = Free;
    Hive->FileSetSize = FileSetSize;
    Hive->FileWrite = FileWrite;
    Hive->FileRead = FileRead;
    Hive->FileFlush = FileFlush;
 
    Hive->RefreshCount = 0;
    Hive->StorageTypeCount = HTYPE_COUNT;
    Hive->Cluster = Cluster;
    Hive->BaseBlockAlloc = sizeof(HBASE_BLOCK); // == HBLOCK_SIZE
 
    Hive->Version = HSYS_MINOR;
#if (NTDDI_VERSION < NTDDI_VISTA)
    Hive->Log = (FileType == HFILE_TYPE_LOG);
#endif
    Hive->HiveFlags = HiveFlags & ~HIVE_NOLAZYFLUSH;
 
    // TODO: The CellRoutines point to different callbacks
    // depending on the OperationType.
    Hive->GetCellRoutine = HvpGetCellData;
    Hive->ReleaseCellRoutine = NULL;
 
    switch (OperationType)
    {
        case HINIT_CREATE:
            Status = HvpCreateHive(Hive, FileName);
            break;
 
        case HINIT_MEMORY:
            Status = HvpInitializeMemoryHive(Hive, HiveData, FileName);
            break;
 
        case HINIT_FLAT:
            Status = HvpInitializeFlatHive(Hive, HiveData);
            break;
 
        case HINIT_FILE:
        {
            Status = HvLoadHive(Hive, FileName);
            if ((Status != STATUS_SUCCESS) &&
                (Status != STATUS_REGISTRY_RECOVERED))
            {
                /* Unrecoverable failure */
                return Status;
            }
 
            /* Check for previous damage */
            ASSERT(Status != STATUS_REGISTRY_RECOVERED);
            break;
        }
 
        case HINIT_MEMORY_INPLACE:
            // Status = HvpInitializeMemoryInplaceHive(Hive, HiveData);
            // break;
 
        case HINIT_MAPFILE:
 
        default:
        /* FIXME: A better return status value is needed */
        Status = STATUS_NOT_IMPLEMENTED;
        ASSERT(FALSE);
    }
 
    if (!NT_SUCCESS(Status)) return Status;
 
    /* HACK: ROS: Init root key cell and prepare the hive */
    // r31253
    // if (OperationType == HINIT_CREATE) CmCreateRootNode(Hive, L"");
    if (OperationType != HINIT_CREATE) CmPrepareHive(Hive);
 
    return Status;
}

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

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;
}

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(), CmpSelectLeaf(), CmpSetValueKeyExisting(), CmpSetValueKeyNew(), CmpSplitLeaf(), 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(), HvpVerifyHiveHeader(), HvpWriteHive(), and HvpWriteLog().

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

)

Definition at line 243 of file hivewrt.c.

{
    ASSERT(RegistryHive->ReadOnly == FALSE);
 
    if (RtlFindSetBits(&RegistryHive->DirtyVector, 1, 0) == ~0U)
    {
        return TRUE;
    }
 
    /* Update hive header modification time */
    KeQuerySystemTime(&RegistryHive->BaseBlock->TimeStamp);
 
    /* Update log file */
    if (!HvpWriteLog(RegistryHive))
    {
        return FALSE;
    }
 
    /* Update hive file */
    if (!HvpWriteHive(RegistryHive, TRUE))
    {
        return FALSE;
    }
 
    /* Clear dirty bitmap. */
    RtlClearAllBits(&RegistryHive->DirtyVector);
    RegistryHive->DirtyCount = 0;
 
    return TRUE;
}

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

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().

HvWriteHive()

BOOLEAN CMAPI HvWriteHive

(

PHHIVE

RegistryHive

)

Definition at line 285 of file hivewrt.c.

{
    ASSERT(RegistryHive->ReadOnly == FALSE);
 
    /* Update hive header modification time */
    KeQuerySystemTime(&RegistryHive->BaseBlock->TimeStamp);
 
    /* Update hive file */
    if (!HvpWriteHive(RegistryHive, FALSE))
    {
        return FALSE;
    }
 
    return TRUE;
}

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

Variable Documentation

CmlibTraceLevel

ULONG CmlibTraceLevel

extern

Definition at line 12 of file cminit.c.