cmvalue.c File Reference

#include "cmlib.h"
#include <debug.h>

Include dependency graph for cmvalue.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
BOOLEAN NTAPI	CmpMarkValueDataDirty (IN PHHIVE Hive, IN PCM_KEY_VALUE Value)
BOOLEAN NTAPI	CmpFreeValueData (IN PHHIVE Hive, IN HCELL_INDEX DataCell, IN ULONG DataLength)
BOOLEAN NTAPI	CmpFreeValue (IN PHHIVE Hive, IN HCELL_INDEX Cell)
HCELL_INDEX NTAPI	CmpFindValueByName (IN PHHIVE Hive, IN PCM_KEY_NODE KeyNode, IN PCUNICODE_STRING Name)
BOOLEAN NTAPI	CmpGetValueData (IN PHHIVE Hive, IN PCM_KEY_VALUE Value, OUT PULONG Length, OUT PVOID *Buffer, OUT PBOOLEAN BufferAllocated, OUT PHCELL_INDEX CellToRelease)
PCELL_DATA NTAPI	CmpValueToData (IN PHHIVE Hive, IN PCM_KEY_VALUE Value, OUT PULONG Length)
NTSTATUS NTAPI	CmpAddValueToList (IN PHHIVE Hive, IN HCELL_INDEX ValueCell, IN ULONG Index, IN HSTORAGE_TYPE StorageType, IN OUT PCHILD_LIST ChildList)
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	CmpRemoveValueFromList (IN PHHIVE Hive, IN ULONG Index, IN OUT PCHILD_LIST ChildList)
HCELL_INDEX NTAPI	CmpCopyCell (IN PHHIVE SourceHive, IN HCELL_INDEX SourceCell, IN PHHIVE DestinationHive, IN HSTORAGE_TYPE StorageType)
HCELL_INDEX NTAPI	CmpCopyValue (IN PHHIVE SourceHive, IN HCELL_INDEX SourceValueCell, IN PHHIVE DestinationHive, IN HSTORAGE_TYPE StorageType)
NTSTATUS NTAPI	CmpCopyKeyValueList (IN PHHIVE SourceHive, IN PCHILD_LIST SrcValueList, IN PHHIVE DestinationHive, IN OUT PCHILD_LIST DestValueList, IN HSTORAGE_TYPE StorageType)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file cmvalue.c.

Function Documentation

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

CmpCopyCell()

HCELL_INDEX NTAPI CmpCopyCell	(	IN PHHIVE	SourceHive,
		IN HCELL_INDEX	SourceCell,
		IN PHHIVE	DestinationHive,
		IN HSTORAGE_TYPE	StorageType
	)

Definition at line 376 of file cmvalue.c.

{
    PCELL_DATA SourceData;
    PCELL_DATA DestinationData = NULL;
    HCELL_INDEX DestinationCell = HCELL_NIL;
    LONG DataSize;
 
    PAGED_CODE();
 
    /* Get the data and the size of the source cell */
    SourceData = HvGetCell(SourceHive, SourceCell);
    DataSize = HvGetCellSize(SourceHive, SourceData);
 
    /* Allocate a new cell in the destination hive */
    DestinationCell = HvAllocateCell(DestinationHive,
                                     DataSize,
                                     StorageType,
                                     HCELL_NIL);
    if (DestinationCell == HCELL_NIL) goto Cleanup;
 
    /* Get the data of the destination cell */
    DestinationData = HvGetCell(DestinationHive, DestinationCell);
 
    /* Copy the data from the source cell to the destination cell */
    RtlMoveMemory(DestinationData, SourceData, DataSize);
 
Cleanup:
 
    /* Release the cells */
    if (DestinationData) HvReleaseCell(DestinationHive, DestinationCell);
    if (SourceData) HvReleaseCell(SourceHive, SourceCell);
 
    /* Return the destination cell index */
    return DestinationCell;
}

Referenced by CmpCopyValue(), and CmpDeepCopyKeyInternal().

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

CmpCopyValue()

HCELL_INDEX NTAPI CmpCopyValue	(	IN PHHIVE	SourceHive,
		IN HCELL_INDEX	SourceValueCell,
		IN PHHIVE	DestinationHive,
		IN HSTORAGE_TYPE	StorageType
	)

Definition at line 417 of file cmvalue.c.

{
    PCM_KEY_VALUE Value, NewValue;
    HCELL_INDEX NewValueCell, NewDataCell;
    PCELL_DATA CellData;
    ULONG SmallData;
    ULONG DataSize;
    BOOLEAN IsSmall;
 
    PAGED_CODE();
 
    /* Get the actual source data */
    Value = (PCM_KEY_VALUE)HvGetCell(SourceHive, SourceValueCell);
    if (!Value) ASSERT(FALSE);
 
    /* Copy the value cell body */
    NewValueCell = CmpCopyCell(SourceHive,
                               SourceValueCell,
                               DestinationHive,
                               StorageType);
    if (NewValueCell == HCELL_NIL)
    {
        /* Not enough storage space */
        goto Quit;
    }
 
    /* Copy the value data */
    IsSmall = CmpIsKeyValueSmall(&DataSize, Value->DataLength);
    if (DataSize == 0)
    {
        /* Nothing to copy */
 
        NewValue = (PCM_KEY_VALUE)HvGetCell(DestinationHive, NewValueCell);
        ASSERT(NewValue);
        NewValue->DataLength = 0;
        NewValue->Data = HCELL_NIL;
        HvReleaseCell(DestinationHive, NewValueCell);
 
        goto Quit;
    }
 
    if (DataSize <= CM_KEY_VALUE_SMALL)
    {
        if (IsSmall)
        {
            /* Small value, copy directly */
            SmallData = Value->Data;
        }
        else
        {
            /* The value is small, but was stored in a regular cell. Get the data from it. */
            CellData = HvGetCell(SourceHive, Value->Data);
            ASSERT(CellData);
            SmallData = *(PULONG)CellData;
            HvReleaseCell(SourceHive, Value->Data);
        }
 
        /* This is a small key, set the data directly inside */
        NewValue = (PCM_KEY_VALUE)HvGetCell(DestinationHive, NewValueCell);
        ASSERT(NewValue);
        NewValue->DataLength = DataSize + CM_KEY_VALUE_SPECIAL_SIZE;
        NewValue->Data = SmallData;
        HvReleaseCell(DestinationHive, NewValueCell);
    }
    else
    {
        /* Big keys are currently unsupported */
        ASSERT_VALUE_BIG(SourceHive, DataSize);
        // Should use CmpGetValueData and CmpSetValueDataNew for big values!
 
        /* Regular value */
 
        /* Copy the data cell */
        NewDataCell = CmpCopyCell(SourceHive,
                                  Value->Data,
                                  DestinationHive,
                                  StorageType);
        if (NewDataCell == HCELL_NIL)
        {
            /* Not enough storage space */
            HvFreeCell(DestinationHive, NewValueCell);
            NewValueCell = HCELL_NIL;
            goto Quit;
        }
 
        NewValue = (PCM_KEY_VALUE)HvGetCell(DestinationHive, NewValueCell);
        ASSERT(NewValue);
        NewValue->DataLength = DataSize;
        NewValue->Data = NewDataCell;
        HvReleaseCell(DestinationHive, NewValueCell);
    }
 
Quit:
    HvReleaseCell(SourceHive, SourceValueCell);
 
    /* Return the copied value body cell index */
    return NewValueCell;
}

Referenced by CmpCopyKeyValueList().

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

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

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

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

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