cmi.h File Reference

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

Go to the source code of this file.

Macros
#define	VERIFY_KEY_CELL(key)

Functions
NTSTATUS	CmiInitializeHive (IN OUT PCMHIVE Hive, IN PCWSTR Name)
NTSTATUS	CmiCreateSecurityKey (IN PHHIVE Hive, IN HCELL_INDEX Cell, IN PUCHAR Descriptor, IN ULONG DescriptorLength)
NTSTATUS	CmiAddSubKey (IN PCMHIVE RegistryHive, IN HCELL_INDEX ParentKeyCellOffset, IN PCUNICODE_STRING SubKeyName, IN BOOLEAN VolatileKey, OUT HCELL_INDEX *pBlockOffset)
NTSTATUS	CmiAddValueKey (IN PCMHIVE RegistryHive, IN PCM_KEY_NODE Parent, IN ULONG ChildIndex, IN PCUNICODE_STRING ValueName, OUT PCM_KEY_VALUE *pValueCell, OUT HCELL_INDEX *pValueCellOffset)

Macro Definition Documentation

VERIFY_KEY_CELL

#define VERIFY_KEY_CELL

(

key

)

Definition at line 29 of file cmi.h.

Function Documentation

CmiAddSubKey()

NTSTATUS CmiAddSubKey	(	IN PCMHIVE	RegistryHive,
		IN HCELL_INDEX	ParentKeyCellOffset,
		IN PCUNICODE_STRING	SubKeyName,
		IN BOOLEAN	VolatileKey,
		OUT HCELL_INDEX *	pBlockOffset
	)

Definition at line 297 of file cmi.c.

{
    PCM_KEY_NODE ParentKeyCell;
    HCELL_INDEX NKBOffset;
    NTSTATUS Status;
 
    /* Create the new key */
    Status = CmiCreateSubKey(RegistryHive, ParentKeyCellOffset, SubKeyName, VolatileKey, &NKBOffset);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Mark the parent cell as dirty */
    HvMarkCellDirty(&RegistryHive->Hive, ParentKeyCellOffset, FALSE);
 
    if (!CmpAddSubKey(&RegistryHive->Hive, ParentKeyCellOffset, NKBOffset))
    {
        /* FIXME: delete newly created cell */
        // CmpFreeKeyByCell(&RegistryHive->Hive, NewCell /*NKBOffset*/, FALSE);
        ASSERT(FALSE);
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Get the parent node */
    ParentKeyCell = (PCM_KEY_NODE)HvGetCell(&RegistryHive->Hive, ParentKeyCellOffset);
    if (!ParentKeyCell)
    {
        /* FIXME: delete newly created cell */
        return STATUS_UNSUCCESSFUL;
    }
    VERIFY_KEY_CELL(ParentKeyCell);
 
    /* Update the timestamp */
    KeQuerySystemTime(&ParentKeyCell->LastWriteTime);
 
    /* Check if we need to update name maximum, update it if so */
    if (ParentKeyCell->MaxNameLen < SubKeyName->Length)
        ParentKeyCell->MaxNameLen = SubKeyName->Length;
 
    /* Release the cell */
    HvReleaseCell(&RegistryHive->Hive, ParentKeyCellOffset);
 
    *pBlockOffset = NKBOffset;
    return STATUS_SUCCESS;
}

Referenced by RegpCreateOrOpenKey().

CmiAddValueKey()

NTSTATUS CmiAddValueKey	(	IN PCMHIVE	RegistryHive,
		IN PCM_KEY_NODE	Parent,
		IN ULONG	ChildIndex,
		IN PCUNICODE_STRING	ValueName,
		OUT PCM_KEY_VALUE *	pValueCell,
		OUT HCELL_INDEX *	pValueCellOffset
	)

Definition at line 348 of file cmi.c.

{
    NTSTATUS Status;
    HSTORAGE_TYPE Storage;
    PCM_KEY_VALUE NewValueCell;
    HCELL_INDEX NewValueCellOffset;
 
    Storage = (Parent->Flags & KEY_IS_VOLATILE) ? Volatile : Stable;
 
    NewValueCellOffset = HvAllocateCell(&RegistryHive->Hive,
                               FIELD_OFFSET(CM_KEY_VALUE, Name) +
                               CmpNameSize(&RegistryHive->Hive, (PUNICODE_STRING)ValueName),
                               Storage,
                               HCELL_NIL);
    if (NewValueCellOffset == HCELL_NIL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    NewValueCell = (PCM_KEY_VALUE)HvGetCell(&RegistryHive->Hive, NewValueCellOffset);
    if (NewValueCell == NULL)
    {
        HvFreeCell(&RegistryHive->Hive, NewValueCellOffset);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    NewValueCell->Signature = CM_KEY_VALUE_SIGNATURE;
    NewValueCell->NameLength = CmpCopyName(&RegistryHive->Hive,
                                           NewValueCell->Name,
                                           (PUNICODE_STRING)ValueName);
 
    /* Check for compressed name */
    if (NewValueCell->NameLength < ValueName->Length)
    {
        /* This is a compressed name */
        NewValueCell->Flags = VALUE_COMP_NAME;
    }
    else
    {
        /* No flags to set */
        NewValueCell->Flags = 0;
    }
 
    NewValueCell->Type = 0;
    NewValueCell->DataLength = 0;
    NewValueCell->Data = HCELL_NIL;
 
    HvMarkCellDirty(&RegistryHive->Hive, NewValueCellOffset, FALSE);
 
    /* Check if we already have a value list */
    if (Parent->ValueList.Count)
    {
        /* Then make sure it's valid and dirty it */
        ASSERT(Parent->ValueList.List != HCELL_NIL);
        HvMarkCellDirty(&RegistryHive->Hive, Parent->ValueList.List, FALSE);
    }
 
    /* Add this value cell to the child list */
    Status = CmpAddValueToList(&RegistryHive->Hive,
                               NewValueCellOffset,
                               ChildIndex,
                               Storage,
                               &Parent->ValueList);
 
    /* If we failed, free the entire cell, including the data */
    if (!NT_SUCCESS(Status))
    {
        /* Overwrite the status with a known one */
        CmpFreeValue(&RegistryHive->Hive, NewValueCellOffset);
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else
    {
        *pValueCell = NewValueCell;
        *pValueCellOffset = NewValueCellOffset;
        Status = STATUS_SUCCESS;
    }
 
    return Status;
}

Referenced by RegSetValueExW().

CmiCreateSecurityKey()

NTSTATUS CmiCreateSecurityKey	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell,
		IN PUCHAR	Descriptor,
		IN ULONG	DescriptorLength
	)

Definition at line 157 of file cmi.c.

{
    HCELL_INDEX SecurityCell;
    PCM_KEY_NODE Node;
    PCM_KEY_SECURITY Security;
 
    Node = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
    SecurityCell = HvAllocateCell(Hive,
                                  FIELD_OFFSET(CM_KEY_SECURITY, Descriptor) +
                                  DescriptorLength,
                                  Stable,
                                  HCELL_NIL);
    if (SecurityCell == HCELL_NIL)
    {
        HvReleaseCell(Hive, Cell);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Node->Security = SecurityCell;
    Security = (PCM_KEY_SECURITY)HvGetCell(Hive, SecurityCell);
    Security->Signature = CM_KEY_SECURITY_SIGNATURE;
    Security->ReferenceCount = 1;
    Security->DescriptorLength = DescriptorLength;
 
    RtlMoveMemory(&Security->Descriptor,
                  Descriptor,
                  DescriptorLength);
 
    Security->Flink = Security->Blink = SecurityCell;
 
    HvReleaseCell(Hive, SecurityCell);
    HvReleaseCell(Hive, Cell);
 
    return STATUS_SUCCESS;
}

Referenced by ConnectRegistry().

CmiInitializeHive()

NTSTATUS CmiInitializeHive	(	IN OUT PCMHIVE	Hive,
		IN PCWSTR	Name
	)

Definition at line 114 of file cmi.c.

{
    NTSTATUS Status;
 
    RtlZeroMemory(Hive, sizeof(*Hive));
 
    DPRINT("Hive 0x%p\n", Hive);
 
    Status = HvInitialize(&Hive->Hive,
                          HINIT_CREATE,
                          HIVE_NOLAZYFLUSH,
                          HFILE_TYPE_PRIMARY,
                          0,
                          CmpAllocate,
                          CmpFree,
                          CmpFileSetSize,
                          CmpFileWrite,
                          CmpFileRead,
                          CmpFileFlush,
                          1,
                          NULL);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    // HACK: See the HACK from r31253
    if (!CmCreateRootNode(&Hive->Hive, Name))
    {
        HvFree(&Hive->Hive);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Add the new hive to the hive list */
    InsertTailList(&CmiHiveListHead,
                   &Hive->HiveList);
 
    return STATUS_SUCCESS;
}

Referenced by ConnectRegistry(), and RegInitializeRegistry().