mkhive.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <typedefs.h>
#include <cmlib.h>
#include <infhost.h>
#include "reginf.h"
#include "cmi.h"
#include "registry.h"
#include "binhive.h"

Include dependency graph for mkhive.h:

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

Go to the source code of this file.

Macros
#define	_countof(_Array)   (sizeof(_Array) / sizeof(_Array[0]))
#define	STATUS_SUCCESS   ((NTSTATUS)0x00000000)
#define	STATUS_UNSUCCESSFUL   ((NTSTATUS)0xC0000001)
#define	STATUS_OBJECT_NAME_NOT_FOUND   ((NTSTATUS)0xC0000034)
#define	RtlFillMemoryUlong(dst, len, val)   memset(dst, val, len)
#define	CMLIB_HOST
#define	OBJ_NAME_PATH_SEPARATOR   ((WCHAR)L'\\')
#define	ABS_VALUE(V)   (((V) < 0) ? -(V) : (V))
#define	PAGED_CODE()

Typedefs
typedef DWORD	REGSAM
typedef LPVOID	LPSECURITY_ATTRIBUTES
typedef HANDLE	HKEY
typedef HANDLE *	PHKEY

Functions
unsigned char	BitScanForward (ULONG *Index, unsigned long Mask)
unsigned char	BitScanReverse (ULONG *const Index, unsigned long Mask)
VOID NTAPI	RtlInitUnicodeString (IN OUT PUNICODE_STRING DestinationString, IN PCWSTR SourceString)
WCHAR NTAPI	RtlUpcaseUnicodeChar (IN WCHAR Source)
LONG WINAPI	RegQueryValueExW (IN HKEY hKey, IN LPCWSTR lpValueName, IN PULONG lpReserved, OUT PULONG lpType OPTIONAL, OUT PUCHAR lpData OPTIONAL, IN OUT PULONG lpcbData OPTIONAL)
LONG WINAPI	RegSetValueExW (IN HKEY hKey, IN LPCWSTR lpValueName OPTIONAL, IN ULONG Reserved, IN ULONG dwType, IN const UCHAR *lpData, IN ULONG cbData)
LONG WINAPI	RegCloseKey (IN HKEY hKey)
LONG WINAPI	RegDeleteKeyW (IN HKEY hKey, IN LPCWSTR lpSubKey)
LONG WINAPI	RegDeleteValueW (IN HKEY hKey, IN LPCWSTR lpValueName OPTIONAL)
LONG WINAPI	RegCreateKeyW (IN HKEY hKey, IN LPCWSTR lpSubKey, OUT PHKEY phkResult)
LONG WINAPI	RegOpenKeyW (IN HKEY hKey, IN LPCWSTR lpSubKey, OUT PHKEY phkResult)

Variables
LIST_ENTRY	CmiHiveListHead

Macro Definition Documentation

_countof

#define _countof

(

_Array

)

(sizeof(_Array) / sizeof(_Array[0]))

Definition at line 37 of file mkhive.h.

ABS_VALUE

#define ABS_VALUE

(

V

)

(((V) < 0) ? -(V) : (V))

Definition at line 130 of file mkhive.h.

CMLIB_HOST

#define CMLIB_HOST

Definition at line 119 of file mkhive.h.

OBJ_NAME_PATH_SEPARATOR

#define OBJ_NAME_PATH_SEPARATOR   ((WCHAR)L'\\')

Definition at line 127 of file mkhive.h.

PAGED_CODE

#define PAGED_CODE

(

)

Definition at line 131 of file mkhive.h.

RtlFillMemoryUlong

#define RtlFillMemoryUlong	(		dst,
			len,
			val
	)		memset(dst, val, len)

Definition at line 55 of file mkhive.h.

STATUS_OBJECT_NAME_NOT_FOUND

#define STATUS_OBJECT_NAME_NOT_FOUND   ((NTSTATUS)0xC0000034)

Definition at line 49 of file mkhive.h.

STATUS_SUCCESS

#define STATUS_SUCCESS   ((NTSTATUS)0x00000000)

Definition at line 43 of file mkhive.h.

STATUS_UNSUCCESSFUL

#define STATUS_UNSUCCESSFUL   ((NTSTATUS)0xC0000001)

Definition at line 44 of file mkhive.h.

Typedef Documentation

HKEY

typedef HANDLE HKEY

Definition at line 64 of file mkhive.h.

LPSECURITY_ATTRIBUTES

typedef LPVOID LPSECURITY_ATTRIBUTES

Definition at line 63 of file mkhive.h.

PHKEY

typedef HANDLE * PHKEY

Definition at line 64 of file mkhive.h.

REGSAM

typedef DWORD REGSAM

Definition at line 62 of file mkhive.h.

Function Documentation

BitScanForward()

unsigned char BitScanForward	(	ULONG *	Index,
		unsigned long	Mask
	)

Definition at line 177 of file rtl.c.

{
    *Index = 0;
    while (Mask && ((Mask & 1) == 0))
    {
        Mask >>= 1;
        ++(*Index);
    }
    return Mask ? 1 : 0;
}

BitScanReverse()

unsigned char BitScanReverse	(	ULONG *const	Index,
		unsigned long	Mask
	)

Definition at line 188 of file rtl.c.

{
    *Index = 0;
    while (Mask && ((Mask & (1 << 31)) == 0))
    {
        Mask <<= 1;
        ++(*Index);
    }
    return Mask ? 1 : 0;
}

RegCloseKey()

LONG WINAPI RegCloseKey

(

IN HKEY

hKey

)

Definition at line 512 of file registry.c.

{
    PMEMKEY Key = HKEY_TO_MEMKEY(hKey); // ParentKey
 
    /* Free the object */
    free(Key);
 
    return ERROR_SUCCESS;
}

RegCreateKeyW()

LONG WINAPI RegCreateKeyW	(	IN HKEY	hKey,
		IN LPCWSTR	lpSubKey,
		OUT PHKEY	phkResult
	)

Definition at line 524 of file registry.c.

{
    return RegpCreateOrOpenKey(hKey, lpSubKey, TRUE, FALSE, phkResult);
}

RegDeleteKeyW()

LONG WINAPI RegDeleteKeyW	(	IN HKEY	hKey,
		IN LPCWSTR	lpSubKey
	)

Definition at line 552 of file registry.c.

{
    LONG rc;
    NTSTATUS Status;
    HKEY hTargetKey;
    PMEMKEY Key; // ParentKey
    PHHIVE Hive;
    PCM_KEY_NODE KeyNode; // ParentNode
    PCM_KEY_NODE Parent;
    HCELL_INDEX ParentCell;
 
    if (lpSubKey)
    {
        rc = RegOpenKeyW(hKey, lpSubKey, &hTargetKey);
        if (rc != ERROR_SUCCESS)
            return rc;
    }
    else
    {
        hTargetKey = hKey;
        rc = ERROR_SUCCESS;
    }
 
    /* Don't allow deleting the root */
    if (hTargetKey == RootKey)
    {
        /* Fail */
        rc = ERROR_ACCESS_DENIED; // STATUS_CANNOT_DELETE;
        goto Quit;
    }
 
    /* Get the hive and node */
    Key = HKEY_TO_MEMKEY(hTargetKey);
    Hive = &Key->RegistryHive->Hive;
 
    /* Get the key node */
    KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Key->KeyCellOffset);
    if (!KeyNode)
    {
        rc = ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
        goto Quit;
    }
 
    ASSERT(KeyNode->Signature == CM_KEY_NODE_SIGNATURE);
 
    /* Check if we don't have any children */
    if (!(KeyNode->SubKeyCounts[Stable] + KeyNode->SubKeyCounts[Volatile]) &&
        !(KeyNode->Flags & KEY_NO_DELETE))
    {
        /* Get the parent and free the cell */
        ParentCell = KeyNode->Parent;
        Status = CmpFreeKeyByCell(Hive, Key->KeyCellOffset, TRUE);
        if (NT_SUCCESS(Status))
        {
            /* Get the parent node */
            Parent = (PCM_KEY_NODE)HvGetCell(Hive, ParentCell);
            if (Parent)
            {
                /* Make sure we're dirty */
                ASSERT(HvIsCellDirty(Hive, ParentCell));
 
                /* Update the write time */
                KeQuerySystemTime(&Parent->LastWriteTime);
 
                /* Release the cell */
                HvReleaseCell(Hive, ParentCell);
            }
 
            rc = ERROR_SUCCESS;
        }
        else
        {
            /* Fail */
            rc = ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
        }
    }
    else
    {
        /* Fail */
        rc = ERROR_ACCESS_DENIED; // STATUS_CANNOT_DELETE;
    }
 
    /* Release the cell */
    HvReleaseCell(Hive, Key->KeyCellOffset);
 
Quit:
    if (lpSubKey)
        RegCloseKey(hTargetKey);
 
    return rc;
}

RegDeleteValueW()

LONG WINAPI RegDeleteValueW	(	IN HKEY	hKey,
		IN LPCWSTR lpValueName	OPTIONAL
	)

Definition at line 901 of file registry.c.

{
    LONG rc;
    NTSTATUS Status;
    PMEMKEY Key = HKEY_TO_MEMKEY(hKey); // ParentKey
    PHHIVE Hive = &Key->RegistryHive->Hive;
    PCM_KEY_NODE KeyNode; // ParentNode
    PCM_KEY_VALUE ValueCell;
    HCELL_INDEX CellIndex;
    ULONG ChildIndex;
    UNICODE_STRING ValueNameString;
 
    KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Key->KeyCellOffset);
    if (!KeyNode)
        return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
 
    ASSERT(KeyNode->Signature == CM_KEY_NODE_SIGNATURE);
 
    /* Initialize value name string */
    RtlInitUnicodeString(&ValueNameString, lpValueName);
    if (!CmpFindNameInList(Hive,
                           &KeyNode->ValueList,
                           &ValueNameString,
                           &ChildIndex,
                           &CellIndex))
    {
        /* Sanity check */
        ASSERT(CellIndex == HCELL_NIL);
    }
    if (CellIndex == HCELL_NIL)
    {
        rc = ERROR_FILE_NOT_FOUND; // STATUS_OBJECT_NAME_NOT_FOUND;
        goto Quit;
    }
 
    /* We found the value, mark all relevant cells dirty */
    HvMarkCellDirty(Hive, Key->KeyCellOffset, FALSE);
    HvMarkCellDirty(Hive, KeyNode->ValueList.List, FALSE);
    HvMarkCellDirty(Hive, CellIndex, FALSE);
 
    /* Get the key value */
    ValueCell = (PCM_KEY_VALUE)HvGetCell(Hive, CellIndex);
    ASSERT(ValueCell);
 
    /* Mark it and all related data as dirty */
    if (!CmpMarkValueDataDirty(Hive, ValueCell))
    {
        /* Not enough log space, fail */
        rc = ERROR_NO_LOG_SPACE; // STATUS_NO_LOG_SPACE;
        goto Quit;
    }
 
    /* Sanity checks */
    ASSERT(HvIsCellDirty(Hive, KeyNode->ValueList.List));
    ASSERT(HvIsCellDirty(Hive, CellIndex));
 
    /* Remove the value from the child list */
    Status = CmpRemoveValueFromList(Hive, ChildIndex, &KeyNode->ValueList);
    if (!NT_SUCCESS(Status))
    {
        /* Set known error */
        rc = ERROR_NO_SYSTEM_RESOURCES; // STATUS_INSUFFICIENT_RESOURCES;
        goto Quit;
    }
 
    /* Remove the value and its data itself */
    if (!CmpFreeValue(Hive, CellIndex))
    {
        /* Failed to free the value, fail */
        rc = ERROR_NO_SYSTEM_RESOURCES; // STATUS_INSUFFICIENT_RESOURCES;
        goto Quit;
    }
 
    /* Set the last write time */
    KeQuerySystemTime(&KeyNode->LastWriteTime);
 
    /* Sanity check */
    ASSERT(HvIsCellDirty(Hive, Key->KeyCellOffset));
 
    /* Check if the value list is empty now */
    if (!KeyNode->ValueList.Count)
    {
        /* Then clear key node data */
        KeyNode->MaxValueNameLen = 0;
        KeyNode->MaxValueDataLen = 0;
    }
 
    /* Change default Status to success */
    rc = ERROR_SUCCESS;
 
Quit:
    /* Check if we had a value */
    if (ValueCell)
    {
        /* Release the child cell */
        ASSERT(CellIndex != HCELL_NIL);
        HvReleaseCell(Hive, CellIndex);
    }
 
    /* Release the parent cell, if any */
    if (KeyNode)
        HvReleaseCell(Hive, Key->KeyCellOffset);
 
    return rc;
}

RegOpenKeyW()

LONG WINAPI RegOpenKeyW	(	IN HKEY	hKey,
		IN LPCWSTR	lpSubKey,
		OUT PHKEY	phkResult
	)

Definition at line 647 of file registry.c.

{
    return RegpCreateOrOpenKey(hKey, lpSubKey, FALSE, FALSE, phkResult);
}

RegQueryValueExW()

LONG WINAPI RegQueryValueExW	(	IN HKEY	hKey,
		IN LPCWSTR	lpValueName,
		IN PULONG	lpReserved,
		OUT PULONG lpType	OPTIONAL,
		OUT PUCHAR lpData	OPTIONAL,
		IN OUT PULONG lpcbData	OPTIONAL
	)

Definition at line 862 of file registry.c.

{
    PMEMKEY ParentKey = HKEY_TO_MEMKEY(hKey);
    PHHIVE Hive = &ParentKey->RegistryHive->Hive;
    PCM_KEY_NODE KeyNode;
    PCM_KEY_VALUE ValueCell;
    HCELL_INDEX CellIndex;
    UNICODE_STRING ValueNameString;
 
    KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, ParentKey->KeyCellOffset);
    if (!KeyNode)
        return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
 
    ASSERT(KeyNode->Signature == CM_KEY_NODE_SIGNATURE);
 
    /* Initialize value name string */
    RtlInitUnicodeString(&ValueNameString, lpValueName);
    CellIndex = CmpFindValueByName(Hive, KeyNode, &ValueNameString);
    if (CellIndex == HCELL_NIL)
        return ERROR_FILE_NOT_FOUND; // STATUS_OBJECT_NAME_NOT_FOUND;
 
    /* Get the value cell */
    ValueCell = (PCM_KEY_VALUE)HvGetCell(Hive, CellIndex);
    ASSERT(ValueCell != NULL);
 
    RepGetValueData(Hive, ValueCell, lpType, lpData, lpcbData);
 
    HvReleaseCell(Hive, CellIndex);
 
    return ERROR_SUCCESS;
}

RegSetValueExW()

LONG WINAPI RegSetValueExW	(	IN HKEY	hKey,
		IN LPCWSTR lpValueName	OPTIONAL,
		IN ULONG	Reserved,
		IN ULONG	dwType,
		IN const UCHAR *	lpData,
		IN ULONG	cbData
	)

Definition at line 656 of file registry.c.

{
    PMEMKEY Key = HKEY_TO_MEMKEY(hKey); // ParentKey
    PHHIVE Hive;
    PCM_KEY_NODE KeyNode; // ParentNode
    PCM_KEY_VALUE ValueCell;
    ULONG ChildIndex;
    HCELL_INDEX CellIndex;
    UNICODE_STRING ValueNameString;
 
    PVOID DataCell;
    ULONG DataCellSize;
    NTSTATUS Status;
 
    if (dwType == REG_LINK)
    {
        PMEMKEY DestKey;
 
        /* Special handling of registry links */
        if (cbData != sizeof(PVOID))
            return ERROR_INVALID_PARAMETER; // STATUS_INVALID_PARAMETER;
 
        DestKey = HKEY_TO_MEMKEY(*(PHKEY)lpData);
 
        // FIXME: Add additional checks for the validity of DestKey
 
        /* Create the link in registry hive (if applicable) */
        if (Key->RegistryHive != DestKey->RegistryHive)
            return ERROR_SUCCESS;
 
        DPRINT1("Save link to registry\n");
        return ERROR_INVALID_FUNCTION; // STATUS_NOT_IMPLEMENTED;
    }
 
    if ((cbData & ~CM_KEY_VALUE_SPECIAL_SIZE) != cbData)
        return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
 
    Hive = &Key->RegistryHive->Hive;
 
    KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Key->KeyCellOffset);
    if (!KeyNode)
        return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
 
    ASSERT(KeyNode->Signature == CM_KEY_NODE_SIGNATURE);
 
    /* Mark the parent as dirty since we are going to create a new value in it */
    HvMarkCellDirty(Hive, Key->KeyCellOffset, FALSE);
 
    /* Initialize value name string */
    RtlInitUnicodeString(&ValueNameString, lpValueName);
    if (!CmpFindNameInList(Hive,
                           &KeyNode->ValueList,
                           &ValueNameString,
                           &ChildIndex,
                           &CellIndex))
    {
        /* Sanity check */
        ASSERT(CellIndex == HCELL_NIL);
        /* Fail */
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }
    if (CellIndex == HCELL_NIL)
    {
        /* The value doesn't exist, create a new one */
        Status = CmiAddValueKey(Key->RegistryHive,
                                KeyNode,
                                ChildIndex,
                                &ValueNameString,
                                &ValueCell,
                                &CellIndex);
    }
    else
    {
        /* The value already exists, use it. Get the value cell. */
        ValueCell = (PCM_KEY_VALUE)HvGetCell(&Key->RegistryHive->Hive, CellIndex);
        ASSERT(ValueCell != NULL);
        Status = STATUS_SUCCESS;
    }
 
    // /**/HvReleaseCell(Hive, CellIndex);/**/
 
    if (!NT_SUCCESS(Status))
        return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
 
    /* Get size of the allocated cell (if any) */
    if (!(ValueCell->DataLength & CM_KEY_VALUE_SPECIAL_SIZE) &&
         (ValueCell->DataLength & ~CM_KEY_VALUE_SPECIAL_SIZE) != 0)
    {
        DataCell = HvGetCell(Hive, ValueCell->Data);
        if (!DataCell)
            return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
 
        DataCellSize = (ULONG)(-HvGetCellSize(Hive, DataCell));
    }
    else
    {
        DataCell = NULL;
        DataCellSize = 0;
    }
 
    if (cbData <= sizeof(HCELL_INDEX))
    {
        /* If data size <= sizeof(HCELL_INDEX) then store data in the data offset */
        DPRINT("ValueCell->DataLength %u\n", ValueCell->DataLength);
        if (DataCell)
            HvFreeCell(Hive, ValueCell->Data);
 
        RtlCopyMemory(&ValueCell->Data, lpData, cbData);
        ValueCell->DataLength = (cbData | CM_KEY_VALUE_SPECIAL_SIZE);
        ValueCell->Type = dwType;
    }
    else
    {
        if (cbData > DataCellSize)
        {
            /* New data size is larger than the current, destroy current
             * data block and allocate a new one. */
            HCELL_INDEX NewOffset;
 
            DPRINT("ValueCell->DataLength %u\n", ValueCell->DataLength);
 
            NewOffset = HvAllocateCell(Hive, cbData, Stable, HCELL_NIL);
            if (NewOffset == HCELL_NIL)
            {
                DPRINT("HvAllocateCell() has failed!\n");
                return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
            }
 
            if (DataCell)
                HvFreeCell(Hive, ValueCell->Data);
 
            ValueCell->Data = NewOffset;
            DataCell = (PVOID)HvGetCell(Hive, NewOffset);
        }
 
        /* Copy new contents to cell */
        RtlCopyMemory(DataCell, lpData, cbData);
        ValueCell->DataLength = (cbData & ~CM_KEY_VALUE_SPECIAL_SIZE);
        ValueCell->Type = dwType;
        HvMarkCellDirty(Hive, ValueCell->Data, FALSE);
    }
 
    HvMarkCellDirty(Hive, CellIndex, FALSE);
 
    /* Check if the maximum value name length changed, update it if so */
    if (KeyNode->MaxValueNameLen < ValueNameString.Length)
        KeyNode->MaxValueNameLen = ValueNameString.Length;
 
    /* Check if the maximum data length changed, update it if so */
    if (KeyNode->MaxValueDataLen < cbData)
        KeyNode->MaxValueDataLen = cbData;
 
    /* Save the write time */
    KeQuerySystemTime(&KeyNode->LastWriteTime);
 
    return ERROR_SUCCESS;
}

RtlInitUnicodeString()

VOID NTAPI RtlInitUnicodeString	(	IN OUT PUNICODE_STRING	DestinationString,
		IN PCWSTR	SourceString
	)

Definition at line 641 of file unicode.c.

{
    SIZE_T Size;
    CONST SIZE_T MaxSize = (MAXUSHORT & ~1) - sizeof(UNICODE_NULL); // an even number
 
    if (SourceString)
    {
        Size = wcslen(SourceString) * sizeof(WCHAR);
        __analysis_assume(Size <= MaxSize);
 
        if (Size > MaxSize)
            Size = MaxSize;
        DestinationString->Length = (USHORT)Size;
        DestinationString->MaximumLength = (USHORT)Size + sizeof(UNICODE_NULL);
    }
    else
    {
        DestinationString->Length = 0;
        DestinationString->MaximumLength = 0;
    }
 
    DestinationString->Buffer = (PWCHAR)SourceString;
}

Referenced by RtlAppendUnicodeToString().

RtlUpcaseUnicodeChar()

WCHAR NTAPI RtlUpcaseUnicodeChar

(

IN WCHAR

Source

)

Definition at line 721 of file nls.c.

{
    PAGED_CODE_RTL();
 
    return RtlpUpcaseUnicodeChar(Source);
}

Referenced by RtlCompareUnicodeString().

Variable Documentation

CmiHiveListHead

LIST_ENTRY CmiHiveListHead

extern

Definition at line 385 of file registry.c.

Referenced by CmiInitializeHive(), and RegInitializeRegistry().