/* INCLUDES *****************************************************************/
-#ifdef WIN32_REGDBG
-#include "cm_win32.h"
-#else
#include <ddk/ntddk.h>
#include <roscfg.h>
#include <internal/ob.h>
#include <internal/debug.h>
#include "cm.h"
-#endif
/* GLOBALS ******************************************************************/
wcsncpy(NodeInformation->Name + SubKeyCell->NameSize ,
(PWCHAR) pClassData->Data,
SubKeyCell->ClassSize);
- CmiReleaseBlock(RegistryHive, pClassData);
}
}
break;
wcsncpy(FullInformation->Class,
(PWCHAR) pClassData->Data,
SubKeyCell->ClassSize);
- CmiReleaseBlock(RegistryHive, pClassData);
}
}
break;
}
- CmiReleaseBlock(RegistryHive, SubKeyCell);
ExReleaseResourceLite(&KeyObject->RegistryHive->HiveResource);
ObDereferenceObject(KeyObject);
RtlCopyMemory(ValuePartialInformation->Data,
DataCell->Data,
ValueCell->DataSize & LONG_MAX);
- CmiReleaseBlock(RegistryHive, DataCell);
}
else
{
+ ValueFullInformation->DataOffset,
DataCell->Data,
ValueCell->DataSize & LONG_MAX);
- CmiReleaseBlock(RegistryHive, DataCell);
}
else
{
ExAcquireResourceExclusiveLite(&RegistryHive->HiveResource,
TRUE);
- if (IsPermanentHive(RegistryHive))
+ if (IsVolatileHive(RegistryHive))
{
- /* Flush non-volatile hive */
- Status = CmiFlushRegistryHive(RegistryHive);
+ Status = STATUS_SUCCESS;
}
else
{
- Status = STATUS_SUCCESS;
+ /* Flush non-volatile hive */
+ Status = CmiFlushRegistryHive(RegistryHive);
}
ExReleaseResourceLite(&RegistryHive->HiveResource);
wcsncpy(NodeInformation->Name + KeyObject->NameSize * sizeof(WCHAR),
(PWCHAR)pClassData->Data,
KeyCell->ClassSize);
- CmiReleaseBlock(RegistryHive, pClassData);
}
*ResultLength = sizeof(KEY_NODE_INFORMATION)
+ KeyObject->NameSize * sizeof(WCHAR)
wcsncpy(FullInformation->Class,
(PWCHAR)pClassData->Data,
KeyCell->ClassSize);
- CmiReleaseBlock(RegistryHive, pClassData);
}
*ResultLength = sizeof(KEY_FULL_INFORMATION) + KeyCell->ClassSize;
}
RtlCopyMemory(ValuePartialInformation->Data,
DataCell->Data,
ValueCell->DataSize & LONG_MAX);
- CmiReleaseBlock(RegistryHive, DataCell);
}
else
{
+ ValueFullInformation->DataOffset,
DataCell->Data,
ValueCell->DataSize & LONG_MAX);
- CmiReleaseBlock(RegistryHive, DataCell);
}
else
{
RtlCopyMemory(DataCell->Data, Data, DataSize);
ValueCell->DataSize = DataSize;
ValueCell->DataType = Type;
- CmiReleaseBlock(RegistryHive, DataCell);
/* Update time of heap */
- if (IsPermanentHive(RegistryHive))
+ if (!IsVolatileHive(RegistryHive))
{
- ZwQuerySystemTime((PTIME) &pBin->DateModified);
+ NtQuerySystemTime((PTIME) &pBin->DateModified);
}
CmiMarkBlockDirty(RegistryHive, ValueCell->DataOffset);
}
RtlCopyMemory(&NewDataCell->Data[0], Data, DataSize);
ValueCell->DataSize = DataSize;
ValueCell->DataType = Type;
- CmiReleaseBlock(RegistryHive, NewDataCell);
ValueCell->DataOffset = NewOffset;
CmiMarkBlockDirty(RegistryHive, ValueCell->DataOffset);
}
}
/* Update time of heap */
- if (IsPermanentHive(RegistryHive) && CmiGetBlock(RegistryHive, VBOffset, &pBin))
+ if (!IsVolatileHive(RegistryHive) && CmiGetBlock(RegistryHive, VBOffset, &pBin))
{
- ZwQuerySystemTime((PTIME) &pBin->DateModified);
+ NtQuerySystemTime((PTIME) &pBin->DateModified);
}
ExReleaseResourceLite(&KeyObject->RegistryHive->HiveResource);
if (ValueCell->DataSize > 0)
{
- DataCell = CmiGetBlock(RegistryHive, ValueCell->DataOffset, NULL);
- RtlCopyMemory(DataPtr, DataCell->Data, ValueCell->DataSize & LONG_MAX);
- CmiReleaseBlock(RegistryHive, DataCell);
+ DataCell = CmiGetBlock(RegistryHive,
+ ValueCell->DataOffset,
+ NULL);
+ RtlCopyMemory(DataPtr,
+ DataCell->Data,
+ ValueCell->DataSize & LONG_MAX);
}
else
{
{
PKEY_CELL RootKeyCell;
- RegistryHive->Flags |= HIVE_VOLATILE;
+ RegistryHive->Flags |= (HIVE_VOLATILE | HIVE_POINTER);
CmiCreateDefaultHiveHeader(RegistryHive->HiveHeader);
{
MaxName = CurSubKeyCell->NameSize;
}
- CmiReleaseBlock(RegistryHive, CurSubKeyCell);
}
}
- CmiReleaseBlock(RegistryHive, HashBlock);
-
return MaxName;
}
{
MaxClass = CurSubKeyCell->ClassSize;
}
- CmiReleaseBlock(RegistryHive, CurSubKeyCell);
}
}
- CmiReleaseBlock(RegistryHive, HashBlock);
-
return MaxClass;
}
{
MaxValueName = CurValueCell->NameSize;
}
- CmiReleaseBlock(RegistryHive, CurValueCell);
}
- CmiReleaseBlock(RegistryHive, ValueListCell);
-
return MaxValueName;
}
-ULONG
+ULONG
CmiGetMaxValueDataLength(PREGISTRY_HIVE RegistryHive,
- PKEY_CELL KeyCell)
+ PKEY_CELL KeyCell)
{
PVALUE_LIST_CELL ValueListCell;
PVALUE_CELL CurValueCell;
{
MaxValueData = CurValueCell->DataSize & LONG_MAX;
}
- CmiReleaseBlock(RegistryHive, CurValueCell);
}
- CmiReleaseBlock(RegistryHive, ValueListCell);
-
return MaxValueData;
}
assert(RegistryHive);
+ *SubKeyCell = NULL;
KeyLength = strlen(KeyName);
HashBlock = CmiGetBlock(RegistryHive, KeyCell->HashTableOffset, NULL);
- *SubKeyCell = NULL;
if (HashBlock == NULL)
{
return STATUS_SUCCESS;
*BlockOffset = HashBlock->Table[i].KeyOffset;
break;
}
- else
- {
- CmiReleaseBlock(RegistryHive, CurSubKeyCell);
- }
}
}
else
*BlockOffset = HashBlock->Table[i].KeyOffset;
break;
}
- else
- {
- CmiReleaseBlock(RegistryHive, CurSubKeyCell);
- }
}
}
}
-
- CmiReleaseBlock(RegistryHive, HashBlock);
-
+
return STATUS_SUCCESS;
}
SubKey->KeyCell = NewKeyCell;
SubKey->BlockOffset = NKBOffset;
- /* Don't modify hash table if key is volatile and parent is not */
- if (IsVolatileHive(RegistryHive) && (!IsVolatileHive(Parent->RegistryHive)))
+ /* Don't modify hash table if key is located in a pointer-based hive and parent key is not */
+ if (IsPointerHive(RegistryHive) && (!IsPointerHive(Parent->RegistryHive)))
{
return(Status);
}
PVALUE_CELL CurValueCell;
ULONG i;
- ValueListCell = CmiGetBlock(RegistryHive, KeyCell->ValuesOffset, NULL);
-
*ValueCell = NULL;
+ ValueListCell = CmiGetBlock(RegistryHive, KeyCell->ValuesOffset, NULL);
if (ValueListCell == NULL)
{
DPRINT("ValueListCell is NULL\n");
//DPRINT("Found value %s\n", ValueName);
break;
}
- CmiReleaseBlock(RegistryHive, CurValueCell);
}
- CmiReleaseBlock(RegistryHive, ValueListCell);
-
return STATUS_SUCCESS;
}
PVALUE_LIST_CELL ValueListCell;
PVALUE_CELL CurValueCell;
- ValueListCell = CmiGetBlock(RegistryHive, KeyCell->ValuesOffset, NULL);
-
*ValueCell = NULL;
+ ValueListCell = CmiGetBlock(RegistryHive, KeyCell->ValuesOffset, NULL);
if (ValueListCell == NULL)
{
return STATUS_NO_MORE_ENTRIES;
}
CurValueCell = CmiGetBlock(RegistryHive,
- ValueListCell->Values[Index],
- NULL);
-
+ ValueListCell->Values[Index],
+ NULL);
if (CurValueCell != NULL)
{
*ValueCell = CurValueCell;
}
- CmiReleaseBlock(RegistryHive, CurValueCell);
- CmiReleaseBlock(RegistryHive, ValueListCell);
-
return STATUS_SUCCESS;
}
BLOCK_OFFSET VBOffset;
NTSTATUS Status;
+ *pVBOffset = VBOffset;
+
Status = CmiAllocateValueCell(RegistryHive,
&NewValueCell,
&VBOffset,
ValueName);
- *pVBOffset = VBOffset;
-
if (!NT_SUCCESS(Status))
{
return Status;
ValueListCell->Values[KeyCell->NumberOfValues] = VBOffset;
KeyCell->NumberOfValues++;
- CmiReleaseBlock(RegistryHive, ValueListCell);
- CmiReleaseBlock(RegistryHive, NewValueCell);
+
*pValueCell = NewValueCell;
return STATUS_SUCCESS;
{
CmiDestroyValueCell(RegistryHive, CurValueCell, ValueListCell->Values[i]);
- if ((KeyCell->NumberOfValues - 1) < i)
- {
- RtlCopyMemory(&ValueListCell->Values[i],
- &ValueListCell->Values[i + 1],
- sizeof(BLOCK_OFFSET) * (KeyCell->NumberOfValues - 1 - i));
- }
- else
- {
- RtlZeroMemory(&ValueListCell->Values[i], sizeof(BLOCK_OFFSET));
- }
+ if ((KeyCell->NumberOfValues - 1) < i)
+ {
+ RtlCopyMemory(&ValueListCell->Values[i],
+ &ValueListCell->Values[i + 1],
+ sizeof(BLOCK_OFFSET) * (KeyCell->NumberOfValues - 1 - i));
+ }
+ else
+ {
+ RtlZeroMemory(&ValueListCell->Values[i], sizeof(BLOCK_OFFSET));
+ }
- KeyCell->NumberOfValues -= 1;
- break;
+ KeyCell->NumberOfValues -= 1;
+ break;
}
- CmiReleaseBlock(RegistryHive, CurValueCell);
}
- CmiReleaseBlock(RegistryHive, ValueListCell);
-
if (KeyCell->NumberOfValues == 0)
{
CmiDestroyBlock(RegistryHive,
if (HashBlock == NULL)
return NULL;
- if (IsVolatileHive(RegistryHive))
+ if (IsPointerHive(RegistryHive))
{
KeyCell = (PKEY_CELL) HashBlock->Table[Index].KeyOffset;
}
KeyOffset = HashBlock->Table[Index].KeyOffset;
KeyCell = CmiGetBlock(RegistryHive, KeyOffset, NULL);
}
- CmiLockBlock(RegistryHive, KeyCell);
return KeyCell;
}
}
/* Update time of heap */
- if (IsPermanentHive(RegistryHive))
- ZwQuerySystemTime((PTIME) &pBin->DateModified);
+ if (!IsVolatileHive(RegistryHive))
+ NtQuerySystemTime((PTIME) &pBin->DateModified);
}
/* Destroy the value cell */
Status = CmiDestroyBlock(RegistryHive, ValueCell, VBOffset);
/* Update time of heap */
- if (IsPermanentHive(RegistryHive) && CmiGetBlock(RegistryHive, VBOffset, &pBin))
+ if (!IsVolatileHive(RegistryHive) && CmiGetBlock(RegistryHive, VBOffset, &pBin))
{
- ZwQuerySystemTime((PTIME) &pBin->DateModified);
+ NtQuerySystemTime((PTIME) &pBin->DateModified);
}
return Status;
if (NewBlockOffset)
*NewBlockOffset = tmpBin->BlockOffset + REG_HBIN_DATA_OFFSET;
- /* FIXME: set first dword to block_offset of another free bloc */
-
/* Mark new bin dirty */
CmiMarkBinDirty(RegistryHive,
tmpBin->BlockOffset);
BlockSize = (BlockSize + sizeof(DWORD) + 15) & 0xfffffff0;
/* Handle volatile hives first */
- if (IsVolatileHive(RegistryHive))
+ if (IsPointerHive(RegistryHive))
{
NewBlock = ExAllocatePool(NonPagedPool, BlockSize);
{
RtlZeroMemory(NewBlock, BlockSize);
NewBlock->CellSize = BlockSize;
- CmiLockBlock(RegistryHive, NewBlock);
*Block = NewBlock;
if (pBlockOffset)
*pBlockOffset = (BLOCK_OFFSET) NewBlock;
if (Temp)
{
- ZwQuerySystemTime((PTIME) &pBin->DateModified);
+ NtQuerySystemTime((PTIME) &pBin->DateModified);
CmiMarkBlockDirty(RegistryHive, RegistryHive->FreeListOffset[i]);
}
RtlZeroMemory(*Block, BlockSize);
((PCELL_HEADER) (*Block))->CellSize = -BlockSize;
- CmiLockBlock(RegistryHive, *Block);
}
}
NTSTATUS
CmiDestroyBlock(PREGISTRY_HIVE RegistryHive,
- PVOID Block,
- BLOCK_OFFSET Offset)
+ PVOID Block,
+ BLOCK_OFFSET Offset)
{
NTSTATUS Status;
PHBIN pBin;
Status = STATUS_SUCCESS;
- if (IsVolatileHive(RegistryHive))
+ if (IsPointerHive(RegistryHive))
{
- CmiReleaseBlock(RegistryHive, Block);
ExFreePool(Block);
}
else
RtlZeroMemory(((PVOID)pFree) + sizeof(ULONG),
pFree->CellSize - sizeof(ULONG));
- /* add block to the list of free blocks */
+ /* Add block to the list of free blocks */
CmiAddFree(RegistryHive, Block, Offset, TRUE);
- CmiReleaseBlock(RegistryHive, Block);
/* Update time of heap */
- if (IsPermanentHive(RegistryHive) && CmiGetBlock(RegistryHive, Offset,&pBin))
- ZwQuerySystemTime((PTIME) &pBin->DateModified);
+ if (!IsVolatileHive(RegistryHive) && CmiGetBlock(RegistryHive, Offset,&pBin))
+ NtQuerySystemTime((PTIME) &pBin->DateModified);
CmiMarkBlockDirty(RegistryHive, Offset);
-
- /* FIXME: Set first dword to block_offset of another free block ? */
- /* FIXME: Concatenate with previous and next block if free */
}
return Status;
if ((BlockOffset == 0) || (BlockOffset == (ULONG_PTR) -1))
return NULL;
- if (IsVolatileHive(RegistryHive))
+ if (IsPointerHive(RegistryHive))
{
return (PVOID) BlockOffset;
}
}
-VOID
-CmiLockBlock(PREGISTRY_HIVE RegistryHive,
- PVOID Block)
-{
- if (IsPermanentHive(RegistryHive))
- {
- /* FIXME: Implement */
- }
-}
-
-
-VOID
-CmiReleaseBlock(PREGISTRY_HIVE RegistryHive,
- PVOID Block)
-{
- if (IsPermanentHive(RegistryHive))
- {
- /* FIXME: Implement */
- }
-}
-
-
VOID
CmiMarkBlockDirty(PREGISTRY_HIVE RegistryHive,
BLOCK_OFFSET BlockOffset)
ULONG BlockCount;
if (IsVolatileHive(RegistryHive))
- return;
+ return;
DPRINT("CmiMarkBlockDirty(Offset 0x%lx)\n", (ULONG)BlockOffset);
PHBIN Bin;
if (IsVolatileHive(RegistryHive))
- return;
+ return;
DPRINT("CmiMarkBinDirty(Offset 0x%lx)\n", (ULONG)BinOffset);